diff --git a/README.md b/README.md index 9cbcfaa..ab6cff8 100644 --- a/README.md +++ b/README.md @@ -44,6 +44,11 @@ Here's how to build `cimgui.h`: python3 $DEAR_BINDINGS_PATH/dear_bindings.py -o src/cached/cimgui $DEAR_IMGUI_PATH/imgui.h ``` +Here's how to build `cimgui_internal.h`: +```sh +python3 $DEAR_BINDINGS_PATH/dear_bindings.py -o src/cached/cimgui_internal --include $DEAR_IMGUI_PATH/imgui.h $DEAR_IMGUI_PATH/imgui_internal.h +``` + Here's how to build a backend, using Vulkan as an example: ```sh diff --git a/build.zig b/build.zig index 28cb553..98efaf8 100644 --- a/build.zig +++ b/build.zig @@ -49,7 +49,10 @@ pub fn build(b: *std.Build) void { }); dear_imgui_lib.addCSourceFiles(.{ .root = b.path("src/cached"), - .files = &.{"dcimgui.cpp"}, + .files = &.{ + "dcimgui.cpp", + "dcimgui_internal.cpp", + }, .flags = flags, }); b.installArtifact(dear_imgui_lib); @@ -119,6 +122,7 @@ pub fn build(b: *std.Build) void { const dear_imgui_zig = generate_dear_imgui.addOutputFileArg("dear_imgui.zig"); generate_dear_imgui.addFileArg(b.path("src/templates/cimgui_prefix.zig.template")); generate_dear_imgui.addFileArg(b.path("src/templates/cimgui_postfix.zig.template")); + generate_dear_imgui.addFileArg(b.path("src/cached/dcimgui_internal.json")); const dear_imgui_zig_module = b.addModule("dear_imgui", .{ .root_source_file = dear_imgui_zig, .target = target, diff --git a/src/cached/dcimgui_internal.cpp b/src/cached/dcimgui_internal.cpp new file mode 100644 index 0000000..f330d4d --- /dev/null +++ b/src/cached/dcimgui_internal.cpp @@ -0,0 +1,4128 @@ +// THIS FILE HAS BEEN AUTO-GENERATED BY THE 'DEAR BINDINGS' GENERATOR. +// **DO NOT EDIT DIRECTLY** +// https://github.com/dearimgui/dear_bindings + +#include "imgui.h" +#include "imgui_internal.h" + +// API for exported functions +#ifndef CIMGUI_API +#define CIMGUI_API extern "C" +#endif + +#include + +// Wrap this in a namespace to keep it separate from the C++ API +namespace cimgui +{ +extern "C" +{ +#include "dcimgui.h" +#include "dcimgui_internal.h" +} +} +// By-value struct conversions + +static inline cimgui::ImVec2 ConvertFromCPP_ImVec2(const ::ImVec2& src) +{ + cimgui::ImVec2 dest; + dest.x = src.x; + dest.y = src.y; + return dest; +} + +static inline ::ImVec2 ConvertToCPP_ImVec2(const cimgui::ImVec2& src) +{ + ::ImVec2 dest; + dest.x = src.x; + dest.y = src.y; + return dest; +} + +static inline cimgui::ImVec4 ConvertFromCPP_ImVec4(const ::ImVec4& src) +{ + cimgui::ImVec4 dest; + dest.x = src.x; + dest.y = src.y; + dest.z = src.z; + dest.w = src.w; + return dest; +} + +static inline ::ImVec4 ConvertToCPP_ImVec4(const cimgui::ImVec4& src) +{ + ::ImVec4 dest; + dest.x = src.x; + dest.y = src.y; + dest.z = src.z; + dest.w = src.w; + return dest; +} + +static inline cimgui::ImTextureRef ConvertFromCPP_ImTextureRef(const ::ImTextureRef& src) +{ + cimgui::ImTextureRef dest; + dest._TexData = reinterpret_cast(src._TexData); + dest._TexID = src._TexID; + return dest; +} + +static inline ::ImTextureRef ConvertToCPP_ImTextureRef(const cimgui::ImTextureRef& src) +{ + ::ImTextureRef dest; + dest._TexData = reinterpret_cast<::ImTextureData*>(src._TexData); + dest._TexID = src._TexID; + return dest; +} + +static inline cimgui::ImColor ConvertFromCPP_ImColor(const ::ImColor& src) +{ + cimgui::ImColor dest; + dest.Value.x = src.Value.x; + dest.Value.y = src.Value.y; + dest.Value.z = src.Value.z; + dest.Value.w = src.Value.w; + return dest; +} + +static inline ::ImColor ConvertToCPP_ImColor(const cimgui::ImColor& src) +{ + ::ImColor dest; + dest.Value.x = src.Value.x; + dest.Value.y = src.Value.y; + dest.Value.z = src.Value.z; + dest.Value.w = src.Value.w; + return dest; +} + +static inline cimgui::ImVec1 ConvertFromCPP_ImVec1(const ::ImVec1& src) +{ + cimgui::ImVec1 dest; + dest.x = src.x; + return dest; +} + +static inline ::ImVec1 ConvertToCPP_ImVec1(const cimgui::ImVec1& src) +{ + ::ImVec1 dest; + dest.x = src.x; + return dest; +} + +static inline cimgui::ImVec2i ConvertFromCPP_ImVec2i(const ::ImVec2i& src) +{ + cimgui::ImVec2i dest; + dest.x = src.x; + dest.y = src.y; + return dest; +} + +static inline ::ImVec2i ConvertToCPP_ImVec2i(const cimgui::ImVec2i& src) +{ + ::ImVec2i dest; + dest.x = src.x; + dest.y = src.y; + return dest; +} + +static inline cimgui::ImVec2ih ConvertFromCPP_ImVec2ih(const ::ImVec2ih& src) +{ + cimgui::ImVec2ih dest; + dest.x = src.x; + dest.y = src.y; + return dest; +} + +static inline ::ImVec2ih ConvertToCPP_ImVec2ih(const cimgui::ImVec2ih& src) +{ + ::ImVec2ih dest; + dest.x = src.x; + dest.y = src.y; + return dest; +} + +static inline cimgui::ImRect ConvertFromCPP_ImRect(const ::ImRect& src) +{ + cimgui::ImRect dest; + dest.Min.x = src.Min.x; + dest.Min.y = src.Min.y; + dest.Max.x = src.Max.x; + dest.Max.y = src.Max.y; + return dest; +} + +static inline ::ImRect ConvertToCPP_ImRect(const cimgui::ImRect& src) +{ + ::ImRect dest; + dest.Min.x = src.Min.x; + dest.Min.y = src.Min.y; + dest.Max.x = src.Max.x; + dest.Max.y = src.Max.y; + return dest; +} + +static inline cimgui::ImGuiListClipperRange ConvertFromCPP_ImGuiListClipperRange(const ::ImGuiListClipperRange& src) +{ + cimgui::ImGuiListClipperRange dest; + dest.Min = src.Min; + dest.Max = src.Max; + dest.PosToIndexConvert = src.PosToIndexConvert; + dest.PosToIndexOffsetMin = src.PosToIndexOffsetMin; + dest.PosToIndexOffsetMax = src.PosToIndexOffsetMax; + return dest; +} + +static inline ::ImGuiListClipperRange ConvertToCPP_ImGuiListClipperRange(const cimgui::ImGuiListClipperRange& src) +{ + ::ImGuiListClipperRange dest; + dest.Min = src.Min; + dest.Max = src.Max; + dest.PosToIndexConvert = src.PosToIndexConvert; + dest.PosToIndexOffsetMin = src.PosToIndexOffsetMin; + dest.PosToIndexOffsetMax = src.PosToIndexOffsetMax; + return dest; +} + +// Function stubs + +#ifndef IMGUI_DISABLE + +CIMGUI_API ImGuiID cimgui::cImHashData(const void* data, size_t data_size) +{ + return ::ImHashData(data, data_size); +} + +CIMGUI_API ImGuiID cimgui::cImHashDataEx(const void* data, size_t data_size, ImGuiID seed) +{ + return ::ImHashData(data, data_size, seed); +} + +CIMGUI_API ImGuiID cimgui::cImHashStr(const char* data) +{ + return ::ImHashStr(data); +} + +CIMGUI_API ImGuiID cimgui::cImHashStrEx(const char* data, size_t data_size, ImGuiID seed) +{ + return ::ImHashStr(data, data_size, seed); +} + +CIMGUI_API ImU32 cimgui::cImAlphaBlendColors(ImU32 col_a, ImU32 col_b) +{ + return ::ImAlphaBlendColors(col_a, col_b); +} + +CIMGUI_API bool cimgui::cImIsPowerOfTwo(int v) +{ + return ::ImIsPowerOfTwo(v); +} + +CIMGUI_API bool cimgui::cImIsPowerOfTwoImU64(ImU64 v) +{ + return ::ImIsPowerOfTwo(v); +} + +CIMGUI_API int cimgui::cImUpperPowerOfTwo(int v) +{ + return ::ImUpperPowerOfTwo(v); +} + +CIMGUI_API unsigned int cimgui::cImCountSetBits(unsigned int v) +{ + return ::ImCountSetBits(v); +} + +CIMGUI_API int cimgui::cImStricmp(const char* str1, const char* str2) +{ + return ::ImStricmp(str1, str2); +} + +CIMGUI_API int cimgui::cImStrnicmp(const char* str1, const char* str2, size_t count) +{ + return ::ImStrnicmp(str1, str2, count); +} + +CIMGUI_API void cimgui::cImStrncpy(char* dst, const char* src, size_t count) +{ + ::ImStrncpy(dst, src, count); +} + +CIMGUI_API char* cimgui::cImStrdup(const char* str) +{ + return ::ImStrdup(str); +} + +CIMGUI_API void* cimgui::cImMemdup(const void* src, size_t size) +{ + return ::ImMemdup(src, size); +} + +CIMGUI_API char* cimgui::cImStrdupcpy(char* dst, size_t* p_dst_size, const char* str) +{ + return ::ImStrdupcpy(dst, p_dst_size, str); +} + +CIMGUI_API const char* cimgui::cImStrchrRange(const char* str_begin, const char* str_end, char c) +{ + return ::ImStrchrRange(str_begin, str_end, c); +} + +CIMGUI_API const char* cimgui::cImStreolRange(const char* str, const char* str_end) +{ + return ::ImStreolRange(str, str_end); +} + +CIMGUI_API const char* cimgui::cImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end) +{ + return ::ImStristr(haystack, haystack_end, needle, needle_end); +} + +CIMGUI_API void cimgui::cImStrTrimBlanks(char* str) +{ + ::ImStrTrimBlanks(str); +} + +CIMGUI_API const char* cimgui::cImStrSkipBlank(const char* str) +{ + return ::ImStrSkipBlank(str); +} + +CIMGUI_API int cimgui::cImStrlenW(const ImWchar* str) +{ + return ::ImStrlenW(str); +} + +CIMGUI_API const char* cimgui::cImStrbol(const char* buf_mid_line, const char* buf_begin) +{ + return ::ImStrbol(buf_mid_line, buf_begin); +} + +CIMGUI_API char cimgui::cImToUpper(char c) +{ + return ::ImToUpper(c); +} + +CIMGUI_API bool cimgui::cImCharIsBlankA(char c) +{ + return ::ImCharIsBlankA(c); +} + +CIMGUI_API bool cimgui::cImCharIsBlankW(unsigned int c) +{ + return ::ImCharIsBlankW(c); +} + +CIMGUI_API bool cimgui::cImCharIsXdigitA(char c) +{ + return ::ImCharIsXdigitA(c); +} + +CIMGUI_API int cimgui::cImFormatString(char* buf, size_t buf_size, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + auto temp_result = ::ImFormatStringV(buf, buf_size, fmt, args); + va_end(args); + return temp_result; +} + +CIMGUI_API int cimgui::cImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) +{ + return ::ImFormatStringV(buf, buf_size, fmt, args); +} + +CIMGUI_API void cimgui::cImFormatStringToTempBuffer(const char** out_buf, const char** out_buf_end, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + ::ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args); + va_end(args); +} + +CIMGUI_API void cimgui::cImFormatStringToTempBufferV(const char** out_buf, const char** out_buf_end, const char* fmt, va_list args) +{ + ::ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args); +} + +CIMGUI_API const char* cimgui::cImParseFormatFindStart(const char* format) +{ + return ::ImParseFormatFindStart(format); +} + +CIMGUI_API const char* cimgui::cImParseFormatFindEnd(const char* format) +{ + return ::ImParseFormatFindEnd(format); +} + +CIMGUI_API const char* cimgui::cImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size) +{ + return ::ImParseFormatTrimDecorations(format, buf, buf_size); +} + +CIMGUI_API void cimgui::cImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size) +{ + ::ImParseFormatSanitizeForPrinting(fmt_in, fmt_out, fmt_out_size); +} + +CIMGUI_API const char* cimgui::cImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size) +{ + return ::ImParseFormatSanitizeForScanning(fmt_in, fmt_out, fmt_out_size); +} + +CIMGUI_API int cimgui::cImParseFormatPrecision(const char* format, int default_value) +{ + return ::ImParseFormatPrecision(format, default_value); +} + +CIMGUI_API int cimgui::cImTextCharToUtf8(char out_buf[5], unsigned int c) +{ + return ::ImTextCharToUtf8(out_buf, c); +} + +CIMGUI_API int cimgui::cImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_text, const ImWchar* in_text_end) +{ + return ::ImTextStrToUtf8(out_buf, out_buf_size, in_text, in_text_end); +} + +CIMGUI_API int cimgui::cImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end) +{ + return ::ImTextCharFromUtf8(out_char, in_text, in_text_end); +} + +CIMGUI_API int cimgui::cImTextStrFromUtf8(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end) +{ + return ::ImTextStrFromUtf8(out_buf, out_buf_size, in_text, in_text_end); +} + +CIMGUI_API int cimgui::cImTextStrFromUtf8Ex(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end, const char** in_remaining) +{ + return ::ImTextStrFromUtf8(out_buf, out_buf_size, in_text, in_text_end, in_remaining); +} + +CIMGUI_API int cimgui::cImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end) +{ + return ::ImTextCountCharsFromUtf8(in_text, in_text_end); +} + +CIMGUI_API int cimgui::cImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end) +{ + return ::ImTextCountUtf8BytesFromChar(in_text, in_text_end); +} + +CIMGUI_API int cimgui::cImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end) +{ + return ::ImTextCountUtf8BytesFromStr(in_text, in_text_end); +} + +CIMGUI_API const char* cimgui::cImTextFindPreviousUtf8Codepoint(const char* in_text_start, const char* in_text_curr) +{ + return ::ImTextFindPreviousUtf8Codepoint(in_text_start, in_text_curr); +} + +CIMGUI_API int cimgui::cImTextCountLines(const char* in_text, const char* in_text_end) +{ + return ::ImTextCountLines(in_text, in_text_end); +} + +#ifdef IMGUI_DISABLE_FILE_FUNCTIONS + +CIMGUI_API ImFileHandle cimgui::cImFileOpen(const char* __unnamed_arg0__, const char* __unnamed_arg1__) +{ + return ::ImFileOpen(__unnamed_arg0__, __unnamed_arg1__); +} + +CIMGUI_API bool cimgui::cImFileClose(ImFileHandle __unnamed_arg0__) +{ + return ::ImFileClose(__unnamed_arg0__); +} + +CIMGUI_API ImU64 cimgui::cImFileGetSize(ImFileHandle __unnamed_arg0__) +{ + return ::ImFileGetSize(__unnamed_arg0__); +} + +CIMGUI_API ImU64 cimgui::cImFileRead(void* __unnamed_arg0__, ImU64 __unnamed_arg1__, ImU64 __unnamed_arg2__, ImFileHandle __unnamed_arg3__) +{ + return ::ImFileRead(__unnamed_arg0__, __unnamed_arg1__, __unnamed_arg2__, __unnamed_arg3__); +} + +CIMGUI_API ImU64 cimgui::cImFileWrite(const void* __unnamed_arg0__, ImU64 __unnamed_arg1__, ImU64 __unnamed_arg2__, ImFileHandle __unnamed_arg3__) +{ + return ::ImFileWrite(__unnamed_arg0__, __unnamed_arg1__, __unnamed_arg2__, __unnamed_arg3__); +} + +#endif // #ifdef IMGUI_DISABLE_FILE_FUNCTIONS + +#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS + +CIMGUI_API ImFileHandle cimgui::cImFileOpen(const char* filename, const char* mode) +{ + return ::ImFileOpen(filename, mode); +} + +CIMGUI_API bool cimgui::cImFileClose(ImFileHandle file) +{ + return ::ImFileClose(file); +} + +CIMGUI_API ImU64 cimgui::cImFileGetSize(ImFileHandle file) +{ + return ::ImFileGetSize(file); +} + +CIMGUI_API ImU64 cimgui::cImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file) +{ + return ::ImFileRead(data, size, count, file); +} + +CIMGUI_API ImU64 cimgui::cImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file) +{ + return ::ImFileWrite(data, size, count, file); +} + +#endif // #ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS + +CIMGUI_API void* cimgui::cImFileLoadToMemory(const char* filename, const char* mode) +{ + return ::ImFileLoadToMemory(filename, mode); +} + +CIMGUI_API void* cimgui::cImFileLoadToMemoryEx(const char* filename, const char* mode, size_t* out_file_size, int padding_bytes) +{ + return ::ImFileLoadToMemory(filename, mode, out_file_size, padding_bytes); +} + +#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS + +CIMGUI_API float cimgui::cImPow(float x, float y) +{ + return ::ImPow(x, y); +} + +CIMGUI_API double cimgui::cImPowDouble(double x, double y) +{ + return ::ImPow(x, y); +} + +CIMGUI_API float cimgui::cImLog(float x) +{ + return ::ImLog(x); +} + +CIMGUI_API double cimgui::cImLogDouble(double x) +{ + return ::ImLog(x); +} + +CIMGUI_API int cimgui::cImAbs(int x) +{ + return ::ImAbs(x); +} + +CIMGUI_API float cimgui::cImAbsFloat(float x) +{ + return ::ImAbs(x); +} + +CIMGUI_API double cimgui::cImAbsDouble(double x) +{ + return ::ImAbs(x); +} + +CIMGUI_API float cimgui::cImSign(float x) +{ + return ::ImSign(x); +} + +CIMGUI_API double cimgui::cImSignDouble(double x) +{ + return ::ImSign(x); +} + +#ifdef IMGUI_ENABLE_SSE + +CIMGUI_API float cimgui::cImRsqrt(float x) +{ + return ::ImRsqrt(x); +} + +#endif // #ifdef IMGUI_ENABLE_SSE + +#ifndef IMGUI_ENABLE_SSE + +CIMGUI_API float cimgui::cImRsqrtFloat(float x) +{ + return ::ImRsqrt(x); +} + +#endif // #ifndef IMGUI_ENABLE_SSE + +CIMGUI_API double cimgui::cImRsqrtDouble(double x) +{ + return ::ImRsqrt(x); +} + +#endif // #ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS + +CIMGUI_API cimgui::ImVec2 cimgui::cImMin(cimgui::ImVec2 lhs, cimgui::ImVec2 rhs) +{ + return ConvertFromCPP_ImVec2(::ImMin(ConvertToCPP_ImVec2(lhs), ConvertToCPP_ImVec2(rhs))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImMax(cimgui::ImVec2 lhs, cimgui::ImVec2 rhs) +{ + return ConvertFromCPP_ImVec2(::ImMax(ConvertToCPP_ImVec2(lhs), ConvertToCPP_ImVec2(rhs))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImClamp(cimgui::ImVec2 v, cimgui::ImVec2 mn, cimgui::ImVec2 mx) +{ + return ConvertFromCPP_ImVec2(::ImClamp(ConvertToCPP_ImVec2(v), ConvertToCPP_ImVec2(mn), ConvertToCPP_ImVec2(mx))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImLerp(cimgui::ImVec2 a, cimgui::ImVec2 b, float t) +{ + return ConvertFromCPP_ImVec2(::ImLerp(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), t)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImLerpImVec2(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 t) +{ + return ConvertFromCPP_ImVec2(::ImLerp(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(t))); +} + +CIMGUI_API cimgui::ImVec4 cimgui::cImLerpImVec4(cimgui::ImVec4 a, cimgui::ImVec4 b, float t) +{ + return ConvertFromCPP_ImVec4(::ImLerp(ConvertToCPP_ImVec4(a), ConvertToCPP_ImVec4(b), t)); +} + +CIMGUI_API float cimgui::cImSaturate(float f) +{ + return ::ImSaturate(f); +} + +CIMGUI_API float cimgui::cImLengthSqr(cimgui::ImVec2 lhs) +{ + return ::ImLengthSqr(ConvertToCPP_ImVec2(lhs)); +} + +CIMGUI_API float cimgui::cImLengthSqrImVec4(cimgui::ImVec4 lhs) +{ + return ::ImLengthSqr(ConvertToCPP_ImVec4(lhs)); +} + +CIMGUI_API float cimgui::cImInvLength(cimgui::ImVec2 lhs, float fail_value) +{ + return ::ImInvLength(ConvertToCPP_ImVec2(lhs), fail_value); +} + +CIMGUI_API float cimgui::cImTrunc(float f) +{ + return ::ImTrunc(f); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImTruncImVec2(cimgui::ImVec2 v) +{ + return ConvertFromCPP_ImVec2(::ImTrunc(ConvertToCPP_ImVec2(v))); +} + +CIMGUI_API float cimgui::cImFloor(float f) +{ + return ::ImFloor(f); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImFloorImVec2(cimgui::ImVec2 v) +{ + return ConvertFromCPP_ImVec2(::ImFloor(ConvertToCPP_ImVec2(v))); +} + +CIMGUI_API float cimgui::cImTrunc64(float f) +{ + return ::ImTrunc64(f); +} + +CIMGUI_API float cimgui::cImRound64(float f) +{ + return ::ImRound64(f); +} + +CIMGUI_API int cimgui::cImModPositive(int a, int b) +{ + return ::ImModPositive(a, b); +} + +CIMGUI_API float cimgui::cImDot(cimgui::ImVec2 a, cimgui::ImVec2 b) +{ + return ::ImDot(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImRotate(cimgui::ImVec2 v, float cos_a, float sin_a) +{ + return ConvertFromCPP_ImVec2(::ImRotate(ConvertToCPP_ImVec2(v), cos_a, sin_a)); +} + +CIMGUI_API float cimgui::cImLinearSweep(float current, float target, float speed) +{ + return ::ImLinearSweep(current, target, speed); +} + +CIMGUI_API float cimgui::cImLinearRemapClamp(float s0, float s1, float d0, float d1, float x) +{ + return ::ImLinearRemapClamp(s0, s1, d0, d1, x); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImMul(cimgui::ImVec2 lhs, cimgui::ImVec2 rhs) +{ + return ConvertFromCPP_ImVec2(::ImMul(ConvertToCPP_ImVec2(lhs), ConvertToCPP_ImVec2(rhs))); +} + +CIMGUI_API bool cimgui::cImIsFloatAboveGuaranteedIntegerPrecision(float f) +{ + return ::ImIsFloatAboveGuaranteedIntegerPrecision(f); +} + +CIMGUI_API float cimgui::cImExponentialMovingAverage(float avg, float sample, int n) +{ + return ::ImExponentialMovingAverage(avg, sample, n); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImBezierCubicCalc(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, float t) +{ + return ConvertFromCPP_ImVec2(::ImBezierCubicCalc(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), t)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImBezierCubicClosestPoint(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, cimgui::ImVec2 p, int num_segments) +{ + return ConvertFromCPP_ImVec2(::ImBezierCubicClosestPoint(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), ConvertToCPP_ImVec2(p), num_segments)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImBezierCubicClosestPointCasteljau(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, cimgui::ImVec2 p, float tess_tol) +{ + return ConvertFromCPP_ImVec2(::ImBezierCubicClosestPointCasteljau(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), ConvertToCPP_ImVec2(p), tess_tol)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImBezierQuadraticCalc(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, float t) +{ + return ConvertFromCPP_ImVec2(::ImBezierQuadraticCalc(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), t)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImLineClosestPoint(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 p) +{ + return ConvertFromCPP_ImVec2(::ImLineClosestPoint(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(p))); +} + +CIMGUI_API bool cimgui::cImTriangleContainsPoint(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c, cimgui::ImVec2 p) +{ + return ::ImTriangleContainsPoint(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c), ConvertToCPP_ImVec2(p)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::cImTriangleClosestPoint(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c, cimgui::ImVec2 p) +{ + return ConvertFromCPP_ImVec2(::ImTriangleClosestPoint(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c), ConvertToCPP_ImVec2(p))); +} + +CIMGUI_API void cimgui::cImTriangleBarycentricCoords(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c, cimgui::ImVec2 p, float* out_u, float* out_v, float* out_w) +{ + ::ImTriangleBarycentricCoords(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c), ConvertToCPP_ImVec2(p), *out_u, *out_v, *out_w); +} + +CIMGUI_API float cimgui::cImTriangleArea(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c) +{ + return ::ImTriangleArea(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c)); +} + +CIMGUI_API bool cimgui::cImTriangleIsClockwise(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c) +{ + return ::ImTriangleIsClockwise(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetCenter(const cimgui::ImRect* self) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->GetCenter()); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetSize(const cimgui::ImRect* self) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->GetSize()); +} + +CIMGUI_API float cimgui::ImRect_GetWidth(const cimgui::ImRect* self) +{ + return reinterpret_cast(self)->GetWidth(); +} + +CIMGUI_API float cimgui::ImRect_GetHeight(const cimgui::ImRect* self) +{ + return reinterpret_cast(self)->GetHeight(); +} + +CIMGUI_API float cimgui::ImRect_GetArea(const cimgui::ImRect* self) +{ + return reinterpret_cast(self)->GetArea(); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetTL(const cimgui::ImRect* self) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->GetTL()); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetTR(const cimgui::ImRect* self) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->GetTR()); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetBL(const cimgui::ImRect* self) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->GetBL()); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetBR(const cimgui::ImRect* self) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->GetBR()); +} + +CIMGUI_API bool cimgui::ImRect_Contains(const cimgui::ImRect* self, cimgui::ImVec2 p) +{ + return reinterpret_cast(self)->Contains(ConvertToCPP_ImVec2(p)); +} + +CIMGUI_API bool cimgui::ImRect_ContainsImRect(const cimgui::ImRect* self, cimgui::ImRect r) +{ + return reinterpret_cast(self)->Contains(ConvertToCPP_ImRect(r)); +} + +CIMGUI_API bool cimgui::ImRect_ContainsWithPad(const cimgui::ImRect* self, cimgui::ImVec2 p, cimgui::ImVec2 pad) +{ + return reinterpret_cast(self)->ContainsWithPad(ConvertToCPP_ImVec2(p), ConvertToCPP_ImVec2(pad)); +} + +CIMGUI_API bool cimgui::ImRect_Overlaps(const cimgui::ImRect* self, cimgui::ImRect r) +{ + return reinterpret_cast(self)->Overlaps(ConvertToCPP_ImRect(r)); +} + +CIMGUI_API void cimgui::ImRect_Add(cimgui::ImRect* self, cimgui::ImVec2 p) +{ + reinterpret_cast<::ImRect*>(self)->Add(ConvertToCPP_ImVec2(p)); +} + +CIMGUI_API void cimgui::ImRect_AddImRect(cimgui::ImRect* self, cimgui::ImRect r) +{ + reinterpret_cast<::ImRect*>(self)->Add(ConvertToCPP_ImRect(r)); +} + +CIMGUI_API void cimgui::ImRect_Expand(cimgui::ImRect* self, const float amount) +{ + reinterpret_cast<::ImRect*>(self)->Expand(amount); +} + +CIMGUI_API void cimgui::ImRect_ExpandImVec2(cimgui::ImRect* self, cimgui::ImVec2 amount) +{ + reinterpret_cast<::ImRect*>(self)->Expand(ConvertToCPP_ImVec2(amount)); +} + +CIMGUI_API void cimgui::ImRect_Translate(cimgui::ImRect* self, cimgui::ImVec2 d) +{ + reinterpret_cast<::ImRect*>(self)->Translate(ConvertToCPP_ImVec2(d)); +} + +CIMGUI_API void cimgui::ImRect_TranslateX(cimgui::ImRect* self, float dx) +{ + reinterpret_cast<::ImRect*>(self)->TranslateX(dx); +} + +CIMGUI_API void cimgui::ImRect_TranslateY(cimgui::ImRect* self, float dy) +{ + reinterpret_cast<::ImRect*>(self)->TranslateY(dy); +} + +CIMGUI_API void cimgui::ImRect_ClipWith(cimgui::ImRect* self, cimgui::ImRect r) +{ + reinterpret_cast<::ImRect*>(self)->ClipWith(ConvertToCPP_ImRect(r)); +} + +CIMGUI_API void cimgui::ImRect_ClipWithFull(cimgui::ImRect* self, cimgui::ImRect r) +{ + reinterpret_cast<::ImRect*>(self)->ClipWithFull(ConvertToCPP_ImRect(r)); +} + +CIMGUI_API void cimgui::ImRect_Floor(cimgui::ImRect* self) +{ + reinterpret_cast<::ImRect*>(self)->Floor(); +} + +CIMGUI_API bool cimgui::ImRect_IsInverted(const cimgui::ImRect* self) +{ + return reinterpret_cast(self)->IsInverted(); +} + +CIMGUI_API cimgui::ImVec4 cimgui::ImRect_ToVec4(const cimgui::ImRect* self) +{ + return ConvertFromCPP_ImVec4(reinterpret_cast(self)->ToVec4()); +} + +CIMGUI_API size_t cimgui::cImBitArrayGetStorageSizeInBytes(int bitcount) +{ + return ::ImBitArrayGetStorageSizeInBytes(bitcount); +} + +CIMGUI_API void cimgui::cImBitArrayClearAllBits(ImU32* arr, int bitcount) +{ + ::ImBitArrayClearAllBits(arr, bitcount); +} + +CIMGUI_API bool cimgui::cImBitArrayTestBit(const ImU32* arr, int n) +{ + return ::ImBitArrayTestBit(arr, n); +} + +CIMGUI_API void cimgui::cImBitArrayClearBit(ImU32* arr, int n) +{ + ::ImBitArrayClearBit(arr, n); +} + +CIMGUI_API void cimgui::cImBitArraySetBit(ImU32* arr, int n) +{ + ::ImBitArraySetBit(arr, n); +} + +CIMGUI_API void cimgui::cImBitArraySetBitRange(ImU32* arr, int n, int n2) +{ + ::ImBitArraySetBitRange(arr, n, n2); +} + +CIMGUI_API void cimgui::ImBitVector_Create(cimgui::ImBitVector* self, int sz) +{ + reinterpret_cast<::ImBitVector*>(self)->Create(sz); +} + +CIMGUI_API void cimgui::ImBitVector_Clear(cimgui::ImBitVector* self) +{ + reinterpret_cast<::ImBitVector*>(self)->Clear(); +} + +CIMGUI_API bool cimgui::ImBitVector_TestBit(const cimgui::ImBitVector* self, int n) +{ + return reinterpret_cast(self)->TestBit(n); +} + +CIMGUI_API void cimgui::ImBitVector_SetBit(cimgui::ImBitVector* self, int n) +{ + reinterpret_cast<::ImBitVector*>(self)->SetBit(n); +} + +CIMGUI_API void cimgui::ImBitVector_ClearBit(cimgui::ImBitVector* self, int n) +{ + reinterpret_cast<::ImBitVector*>(self)->ClearBit(n); +} + +CIMGUI_API void cimgui::ImStableVector_ImFontBaked_32_clear(cimgui::ImStableVector_ImFontBaked_32* self) +{ + reinterpret_cast*>(self)->clear(); +} + +CIMGUI_API void cimgui::ImStableVector_ImFontBaked_32_resize(cimgui::ImStableVector_ImFontBaked_32* self, int new_size) +{ + reinterpret_cast*>(self)->resize(new_size); +} + +CIMGUI_API void cimgui::ImStableVector_ImFontBaked_32_reserve(cimgui::ImStableVector_ImFontBaked_32* self, int new_cap) +{ + reinterpret_cast*>(self)->reserve(new_cap); +} + +CIMGUI_API void cimgui::ImGuiTextIndex_clear(cimgui::ImGuiTextIndex* self) +{ + reinterpret_cast<::ImGuiTextIndex*>(self)->clear(); +} + +CIMGUI_API int cimgui::ImGuiTextIndex_size(cimgui::ImGuiTextIndex* self) +{ + return reinterpret_cast<::ImGuiTextIndex*>(self)->size(); +} + +CIMGUI_API const char* cimgui::ImGuiTextIndex_get_line_begin(cimgui::ImGuiTextIndex* self, const char* base, int n) +{ + return reinterpret_cast<::ImGuiTextIndex*>(self)->get_line_begin(base, n); +} + +CIMGUI_API const char* cimgui::ImGuiTextIndex_get_line_end(cimgui::ImGuiTextIndex* self, const char* base, int n) +{ + return reinterpret_cast<::ImGuiTextIndex*>(self)->get_line_end(base, n); +} + +CIMGUI_API void cimgui::ImGuiTextIndex_append(cimgui::ImGuiTextIndex* self, const char* base, int old_size, int new_size) +{ + reinterpret_cast<::ImGuiTextIndex*>(self)->append(base, old_size, new_size); +} + +CIMGUI_API cimgui::ImGuiStoragePair* cimgui::cImLowerBound(cimgui::ImGuiStoragePair* in_begin, cimgui::ImGuiStoragePair* in_end, ImGuiID key) +{ + return reinterpret_cast<::cimgui::ImGuiStoragePair*>(::ImLowerBound(reinterpret_cast<::ImGuiStoragePair*>(in_begin), reinterpret_cast<::ImGuiStoragePair*>(in_end), key)); +} + +CIMGUI_API void cimgui::ImDrawListSharedData_SetCircleTessellationMaxError(cimgui::ImDrawListSharedData* self, float max_error) +{ + reinterpret_cast<::ImDrawListSharedData*>(self)->SetCircleTessellationMaxError(max_error); +} + +CIMGUI_API void* cimgui::ImGuiStyleVarInfo_GetVarPtr(const cimgui::ImGuiStyleVarInfo* self, void* parent) +{ + return reinterpret_cast(self)->GetVarPtr(parent); +} + +CIMGUI_API void cimgui::ImGuiMenuColumns_Update(cimgui::ImGuiMenuColumns* self, float spacing, bool window_reappearing) +{ + reinterpret_cast<::ImGuiMenuColumns*>(self)->Update(spacing, window_reappearing); +} + +CIMGUI_API float cimgui::ImGuiMenuColumns_DeclColumns(cimgui::ImGuiMenuColumns* self, float w_icon, float w_label, float w_shortcut, float w_mark) +{ + return reinterpret_cast<::ImGuiMenuColumns*>(self)->DeclColumns(w_icon, w_label, w_shortcut, w_mark); +} + +CIMGUI_API void cimgui::ImGuiMenuColumns_CalcNextTotalWidth(cimgui::ImGuiMenuColumns* self, bool update_offsets) +{ + reinterpret_cast<::ImGuiMenuColumns*>(self)->CalcNextTotalWidth(update_offsets); +} + +CIMGUI_API void cimgui::ImGuiInputTextDeactivatedState_ClearFreeMemory(cimgui::ImGuiInputTextDeactivatedState* self) +{ + reinterpret_cast<::ImGuiInputTextDeactivatedState*>(self)->ClearFreeMemory(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_ClearText(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->ClearText(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_ClearFreeMemory(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->ClearFreeMemory(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_OnKeyPressed(cimgui::ImGuiInputTextState* self, int key) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->OnKeyPressed(key); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_OnCharPressed(cimgui::ImGuiInputTextState* self, unsigned int c) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->OnCharPressed(c); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_CursorAnimReset(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->CursorAnimReset(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_CursorClamp(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->CursorClamp(); +} + +CIMGUI_API bool cimgui::ImGuiInputTextState_HasSelection(const cimgui::ImGuiInputTextState* self) +{ + return reinterpret_cast(self)->HasSelection(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_ClearSelection(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->ClearSelection(); +} + +CIMGUI_API int cimgui::ImGuiInputTextState_GetCursorPos(const cimgui::ImGuiInputTextState* self) +{ + return reinterpret_cast(self)->GetCursorPos(); +} + +CIMGUI_API int cimgui::ImGuiInputTextState_GetSelectionStart(const cimgui::ImGuiInputTextState* self) +{ + return reinterpret_cast(self)->GetSelectionStart(); +} + +CIMGUI_API int cimgui::ImGuiInputTextState_GetSelectionEnd(const cimgui::ImGuiInputTextState* self) +{ + return reinterpret_cast(self)->GetSelectionEnd(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_SelectAll(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->SelectAll(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_ReloadUserBufAndSelectAll(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->ReloadUserBufAndSelectAll(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_ReloadUserBufAndKeepSelection(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->ReloadUserBufAndKeepSelection(); +} + +CIMGUI_API void cimgui::ImGuiInputTextState_ReloadUserBufAndMoveToEnd(cimgui::ImGuiInputTextState* self) +{ + reinterpret_cast<::ImGuiInputTextState*>(self)->ReloadUserBufAndMoveToEnd(); +} + +CIMGUI_API void cimgui::ImGuiNextWindowData_ClearFlags(cimgui::ImGuiNextWindowData* self) +{ + reinterpret_cast<::ImGuiNextWindowData*>(self)->ClearFlags(); +} + +CIMGUI_API void cimgui::ImGuiNextItemData_ClearFlags(cimgui::ImGuiNextItemData* self) +{ + reinterpret_cast<::ImGuiNextItemData*>(self)->ClearFlags(); +} + +CIMGUI_API void cimgui::ImGuiKeyRoutingTable_Clear(cimgui::ImGuiKeyRoutingTable* self) +{ + reinterpret_cast<::ImGuiKeyRoutingTable*>(self)->Clear(); +} + +CIMGUI_API cimgui::ImGuiListClipperRange cimgui::ImGuiListClipperRange_FromIndices(int min, int max) +{ + return ConvertFromCPP_ImGuiListClipperRange(::ImGuiListClipperRange::FromIndices(min, max)); +} + +CIMGUI_API cimgui::ImGuiListClipperRange cimgui::ImGuiListClipperRange_FromPositions(float y1, float y2, int off_min, int off_max) +{ + return ConvertFromCPP_ImGuiListClipperRange(::ImGuiListClipperRange::FromPositions(y1, y2, off_min, off_max)); +} + +CIMGUI_API void cimgui::ImGuiListClipperData_Reset(cimgui::ImGuiListClipperData* self, cimgui::ImGuiListClipper* clipper) +{ + reinterpret_cast<::ImGuiListClipperData*>(self)->Reset(reinterpret_cast<::ImGuiListClipper*>(clipper)); +} + +CIMGUI_API void cimgui::ImGuiNavItemData_Clear(cimgui::ImGuiNavItemData* self) +{ + reinterpret_cast<::ImGuiNavItemData*>(self)->Clear(); +} + +CIMGUI_API void cimgui::ImGuiTypingSelectState_Clear(cimgui::ImGuiTypingSelectState* self) +{ + reinterpret_cast<::ImGuiTypingSelectState*>(self)->Clear(); +} + +CIMGUI_API void cimgui::ImGuiMultiSelectTempData_Clear(cimgui::ImGuiMultiSelectTempData* self) +{ + reinterpret_cast<::ImGuiMultiSelectTempData*>(self)->Clear(); +} + +CIMGUI_API void cimgui::ImGuiMultiSelectTempData_ClearIO(cimgui::ImGuiMultiSelectTempData* self) +{ + reinterpret_cast<::ImGuiMultiSelectTempData*>(self)->ClearIO(); +} + +#ifdef IMGUI_HAS_DOCK + +CIMGUI_API bool cimgui::ImGuiDockNode_IsRootNode(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsRootNode(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsDockSpace(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsDockSpace(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsFloatingNode(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsFloatingNode(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsCentralNode(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsCentralNode(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsHiddenTabBar(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsHiddenTabBar(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsNoTabBar(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsNoTabBar(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsSplitNode(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsSplitNode(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsLeafNode(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsLeafNode(); +} + +CIMGUI_API bool cimgui::ImGuiDockNode_IsEmpty(const cimgui::ImGuiDockNode* self) +{ + return reinterpret_cast(self)->IsEmpty(); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGuiDockNode_Rect(const cimgui::ImGuiDockNode* self) +{ + return ConvertFromCPP_ImRect(reinterpret_cast(self)->Rect()); +} + +CIMGUI_API void cimgui::ImGuiDockNode_SetLocalFlags(cimgui::ImGuiDockNode* self, ImGuiDockNodeFlags flags) +{ + reinterpret_cast<::ImGuiDockNode*>(self)->SetLocalFlags(flags); +} + +CIMGUI_API void cimgui::ImGuiDockNode_UpdateMergedFlags(cimgui::ImGuiDockNode* self) +{ + reinterpret_cast<::ImGuiDockNode*>(self)->UpdateMergedFlags(); +} + +#endif // #ifdef IMGUI_HAS_DOCK + +CIMGUI_API void cimgui::ImGuiViewportP_ClearRequestFlags(cimgui::ImGuiViewportP* self) +{ + reinterpret_cast<::ImGuiViewportP*>(self)->ClearRequestFlags(); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGuiViewportP_CalcWorkRectPos(const cimgui::ImGuiViewportP* self, cimgui::ImVec2 inset_min) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->CalcWorkRectPos(ConvertToCPP_ImVec2(inset_min))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGuiViewportP_CalcWorkRectSize(const cimgui::ImGuiViewportP* self, cimgui::ImVec2 inset_min, cimgui::ImVec2 inset_max) +{ + return ConvertFromCPP_ImVec2(reinterpret_cast(self)->CalcWorkRectSize(ConvertToCPP_ImVec2(inset_min), ConvertToCPP_ImVec2(inset_max))); +} + +CIMGUI_API void cimgui::ImGuiViewportP_UpdateWorkRect(cimgui::ImGuiViewportP* self) +{ + reinterpret_cast<::ImGuiViewportP*>(self)->UpdateWorkRect(); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGuiViewportP_GetMainRect(const cimgui::ImGuiViewportP* self) +{ + return ConvertFromCPP_ImRect(reinterpret_cast(self)->GetMainRect()); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGuiViewportP_GetWorkRect(const cimgui::ImGuiViewportP* self) +{ + return ConvertFromCPP_ImRect(reinterpret_cast(self)->GetWorkRect()); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGuiViewportP_GetBuildWorkRect(const cimgui::ImGuiViewportP* self) +{ + return ConvertFromCPP_ImRect(reinterpret_cast(self)->GetBuildWorkRect()); +} + +CIMGUI_API char* cimgui::ImGuiWindowSettings_GetName(cimgui::ImGuiWindowSettings* self) +{ + return reinterpret_cast<::ImGuiWindowSettings*>(self)->GetName(); +} + +CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDStr(cimgui::ImGuiWindow* self, const char* str) +{ + return reinterpret_cast<::ImGuiWindow*>(self)->GetID(str); +} + +CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDStrEx(cimgui::ImGuiWindow* self, const char* str, const char* str_end) +{ + return reinterpret_cast<::ImGuiWindow*>(self)->GetID(str, str_end); +} + +CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetID(cimgui::ImGuiWindow* self, const void* ptr) +{ + return reinterpret_cast<::ImGuiWindow*>(self)->GetID(ptr); +} + +CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDInt(cimgui::ImGuiWindow* self, int n) +{ + return reinterpret_cast<::ImGuiWindow*>(self)->GetID(n); +} + +CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDFromPos(cimgui::ImGuiWindow* self, cimgui::ImVec2 p_abs) +{ + return reinterpret_cast<::ImGuiWindow*>(self)->GetIDFromPos(ConvertToCPP_ImVec2(p_abs)); +} + +CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDFromRectangle(cimgui::ImGuiWindow* self, cimgui::ImRect r_abs) +{ + return reinterpret_cast<::ImGuiWindow*>(self)->GetIDFromRectangle(ConvertToCPP_ImRect(r_abs)); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGuiWindow_Rect(const cimgui::ImGuiWindow* self) +{ + return ConvertFromCPP_ImRect(reinterpret_cast(self)->Rect()); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGuiWindow_TitleBarRect(const cimgui::ImGuiWindow* self) +{ + return ConvertFromCPP_ImRect(reinterpret_cast(self)->TitleBarRect()); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGuiWindow_MenuBarRect(const cimgui::ImGuiWindow* self) +{ + return ConvertFromCPP_ImRect(reinterpret_cast(self)->MenuBarRect()); +} + +CIMGUI_API cimgui::ImGuiTableColumnSettings* cimgui::ImGuiTableSettings_GetColumnSettings(cimgui::ImGuiTableSettings* self) +{ + return reinterpret_cast<::cimgui::ImGuiTableColumnSettings*>(reinterpret_cast<::ImGuiTableSettings*>(self)->GetColumnSettings()); +} + +CIMGUI_API cimgui::ImGuiIO* cimgui::ImGui_GetIOImGuiContextPtr(cimgui::ImGuiContext* ctx) +{ + return reinterpret_cast<::cimgui::ImGuiIO*>(&::ImGui::GetIO(reinterpret_cast<::ImGuiContext*>(ctx))); +} + +CIMGUI_API cimgui::ImGuiPlatformIO* cimgui::ImGui_GetPlatformIOImGuiContextPtr(cimgui::ImGuiContext* ctx) +{ + return reinterpret_cast<::cimgui::ImGuiPlatformIO*>(&::ImGui::GetPlatformIO(reinterpret_cast<::ImGuiContext*>(ctx))); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetCurrentWindowRead(void) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetCurrentWindowRead()); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetCurrentWindow(void) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetCurrentWindow()); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindWindowByID(ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindWindowByID(id)); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindWindowByName(const char* name) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindWindowByName(name)); +} + +CIMGUI_API void cimgui::ImGui_UpdateWindowParentAndRootLinks(cimgui::ImGuiWindow* window, ImGuiWindowFlags flags, cimgui::ImGuiWindow* parent_window) +{ + ::ImGui::UpdateWindowParentAndRootLinks(reinterpret_cast<::ImGuiWindow*>(window), flags, reinterpret_cast<::ImGuiWindow*>(parent_window)); +} + +CIMGUI_API void cimgui::ImGui_UpdateWindowSkipRefresh(cimgui::ImGuiWindow* window) +{ + ::ImGui::UpdateWindowSkipRefresh(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_CalcWindowNextAutoFitSize(cimgui::ImGuiWindow* window) +{ + return ConvertFromCPP_ImVec2(::ImGui::CalcWindowNextAutoFitSize(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API bool cimgui::ImGui_IsWindowChildOf(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* potential_parent, bool popup_hierarchy, bool dock_hierarchy) +{ + return ::ImGui::IsWindowChildOf(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(potential_parent), popup_hierarchy, dock_hierarchy); +} + +CIMGUI_API bool cimgui::ImGui_IsWindowWithinBeginStackOf(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* potential_parent) +{ + return ::ImGui::IsWindowWithinBeginStackOf(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(potential_parent)); +} + +CIMGUI_API bool cimgui::ImGui_IsWindowAbove(cimgui::ImGuiWindow* potential_above, cimgui::ImGuiWindow* potential_below) +{ + return ::ImGui::IsWindowAbove(reinterpret_cast<::ImGuiWindow*>(potential_above), reinterpret_cast<::ImGuiWindow*>(potential_below)); +} + +CIMGUI_API bool cimgui::ImGui_IsWindowNavFocusable(cimgui::ImGuiWindow* window) +{ + return ::ImGui::IsWindowNavFocusable(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_SetWindowPosImGuiWindowPtr(cimgui::ImGuiWindow* window, cimgui::ImVec2 pos, ImGuiCond cond) +{ + ::ImGui::SetWindowPos(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(pos), cond); +} + +CIMGUI_API void cimgui::ImGui_SetWindowSizeImGuiWindowPtr(cimgui::ImGuiWindow* window, cimgui::ImVec2 size, ImGuiCond cond) +{ + ::ImGui::SetWindowSize(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(size), cond); +} + +CIMGUI_API void cimgui::ImGui_SetWindowCollapsedImGuiWindowPtr(cimgui::ImGuiWindow* window, bool collapsed, ImGuiCond cond) +{ + ::ImGui::SetWindowCollapsed(reinterpret_cast<::ImGuiWindow*>(window), collapsed, cond); +} + +CIMGUI_API void cimgui::ImGui_SetWindowHitTestHole(cimgui::ImGuiWindow* window, cimgui::ImVec2 pos, cimgui::ImVec2 size) +{ + ::ImGui::SetWindowHitTestHole(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(pos), ConvertToCPP_ImVec2(size)); +} + +CIMGUI_API void cimgui::ImGui_SetWindowHiddenAndSkipItemsForCurrentFrame(cimgui::ImGuiWindow* window) +{ + ::ImGui::SetWindowHiddenAndSkipItemsForCurrentFrame(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_SetWindowParentWindowForFocusRoute(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* parent_window) +{ + ::ImGui::SetWindowParentWindowForFocusRoute(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(parent_window)); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGui_WindowRectAbsToRel(cimgui::ImGuiWindow* window, cimgui::ImRect r) +{ + return ConvertFromCPP_ImRect(::ImGui::WindowRectAbsToRel(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(r))); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGui_WindowRectRelToAbs(cimgui::ImGuiWindow* window, cimgui::ImRect r) +{ + return ConvertFromCPP_ImRect(::ImGui::WindowRectRelToAbs(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(r))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_WindowPosAbsToRel(cimgui::ImGuiWindow* window, cimgui::ImVec2 p) +{ + return ConvertFromCPP_ImVec2(::ImGui::WindowPosAbsToRel(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(p))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_WindowPosRelToAbs(cimgui::ImGuiWindow* window, cimgui::ImVec2 p) +{ + return ConvertFromCPP_ImVec2(::ImGui::WindowPosRelToAbs(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(p))); +} + +CIMGUI_API void cimgui::ImGui_FocusWindow(cimgui::ImGuiWindow* window, ImGuiFocusRequestFlags flags) +{ + ::ImGui::FocusWindow(reinterpret_cast<::ImGuiWindow*>(window), flags); +} + +CIMGUI_API void cimgui::ImGui_FocusTopMostWindowUnderOne(cimgui::ImGuiWindow* under_this_window, cimgui::ImGuiWindow* ignore_window, cimgui::ImGuiViewport* filter_viewport, ImGuiFocusRequestFlags flags) +{ + ::ImGui::FocusTopMostWindowUnderOne(reinterpret_cast<::ImGuiWindow*>(under_this_window), reinterpret_cast<::ImGuiWindow*>(ignore_window), reinterpret_cast<::ImGuiViewport*>(filter_viewport), flags); +} + +CIMGUI_API void cimgui::ImGui_BringWindowToFocusFront(cimgui::ImGuiWindow* window) +{ + ::ImGui::BringWindowToFocusFront(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_BringWindowToDisplayFront(cimgui::ImGuiWindow* window) +{ + ::ImGui::BringWindowToDisplayFront(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_BringWindowToDisplayBack(cimgui::ImGuiWindow* window) +{ + ::ImGui::BringWindowToDisplayBack(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_BringWindowToDisplayBehind(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* above_window) +{ + ::ImGui::BringWindowToDisplayBehind(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(above_window)); +} + +CIMGUI_API int cimgui::ImGui_FindWindowDisplayIndex(cimgui::ImGuiWindow* window) +{ + return ::ImGui::FindWindowDisplayIndex(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindBottomMostVisibleWindowWithinBeginStack(cimgui::ImGuiWindow* window) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindBottomMostVisibleWindowWithinBeginStack(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API void cimgui::ImGui_SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags) +{ + ::ImGui::SetNextWindowRefreshPolicy(flags); +} + +CIMGUI_API void cimgui::ImGui_RegisterUserTexture(cimgui::ImTextureData* tex) +{ + ::ImGui::RegisterUserTexture(reinterpret_cast<::ImTextureData*>(tex)); +} + +CIMGUI_API void cimgui::ImGui_UnregisterUserTexture(cimgui::ImTextureData* tex) +{ + ::ImGui::UnregisterUserTexture(reinterpret_cast<::ImTextureData*>(tex)); +} + +CIMGUI_API void cimgui::ImGui_RegisterFontAtlas(cimgui::ImFontAtlas* atlas) +{ + ::ImGui::RegisterFontAtlas(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::ImGui_UnregisterFontAtlas(cimgui::ImFontAtlas* atlas) +{ + ::ImGui::UnregisterFontAtlas(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::ImGui_SetCurrentFont(cimgui::ImFont* font, float font_size_before_scaling, float font_size_after_scaling) +{ + ::ImGui::SetCurrentFont(reinterpret_cast<::ImFont*>(font), font_size_before_scaling, font_size_after_scaling); +} + +CIMGUI_API void cimgui::ImGui_UpdateCurrentFontSize(float restore_font_size_after_scaling) +{ + ::ImGui::UpdateCurrentFontSize(restore_font_size_after_scaling); +} + +CIMGUI_API void cimgui::ImGui_SetFontRasterizerDensity(float rasterizer_density) +{ + ::ImGui::SetFontRasterizerDensity(rasterizer_density); +} + +CIMGUI_API float cimgui::ImGui_GetFontRasterizerDensity(void) +{ + return ::ImGui::GetFontRasterizerDensity(); +} + +CIMGUI_API float cimgui::ImGui_GetRoundedFontSize(float size) +{ + return ::ImGui::GetRoundedFontSize(size); +} + +CIMGUI_API cimgui::ImFont* cimgui::ImGui_GetDefaultFont(void) +{ + return reinterpret_cast<::cimgui::ImFont*>(::ImGui::GetDefaultFont()); +} + +CIMGUI_API void cimgui::ImGui_PushPasswordFont(void) +{ + ::ImGui::PushPasswordFont(); +} + +CIMGUI_API void cimgui::ImGui_PopPasswordFont(void) +{ + ::ImGui::PopPasswordFont(); +} + +CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetForegroundDrawListImGuiWindowPtr(cimgui::ImGuiWindow* window) +{ + return reinterpret_cast<::cimgui::ImDrawList*>(::ImGui::GetForegroundDrawList(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API void cimgui::ImGui_AddDrawListToDrawDataEx(cimgui::ImDrawData* draw_data, cimgui::ImVector_ImDrawListPtr* out_list, cimgui::ImDrawList* draw_list) +{ + ::ImGui::AddDrawListToDrawDataEx(reinterpret_cast<::ImDrawData*>(draw_data), reinterpret_cast<::ImVector<::ImDrawList*>*>(out_list), reinterpret_cast<::ImDrawList*>(draw_list)); +} + +CIMGUI_API void cimgui::ImGui_Initialize(void) +{ + ::ImGui::Initialize(); +} + +CIMGUI_API void cimgui::ImGui_Shutdown(void) +{ + ::ImGui::Shutdown(); +} + +CIMGUI_API void cimgui::ImGui_UpdateInputEvents(bool trickle_fast_inputs) +{ + ::ImGui::UpdateInputEvents(trickle_fast_inputs); +} + +CIMGUI_API void cimgui::ImGui_UpdateHoveredWindowAndCaptureFlags(cimgui::ImVec2 mouse_pos) +{ + ::ImGui::UpdateHoveredWindowAndCaptureFlags(ConvertToCPP_ImVec2(mouse_pos)); +} + +CIMGUI_API void cimgui::ImGui_FindHoveredWindowEx(cimgui::ImVec2 pos, bool find_first_and_in_any_viewport, cimgui::ImGuiWindow** out_hovered_window, cimgui::ImGuiWindow** out_hovered_window_under_moving_window) +{ + ::ImGui::FindHoveredWindowEx(ConvertToCPP_ImVec2(pos), find_first_and_in_any_viewport, reinterpret_cast<::ImGuiWindow**>(out_hovered_window), reinterpret_cast<::ImGuiWindow**>(out_hovered_window_under_moving_window)); +} + +CIMGUI_API void cimgui::ImGui_StartMouseMovingWindow(cimgui::ImGuiWindow* window) +{ + ::ImGui::StartMouseMovingWindow(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_StartMouseMovingWindowOrNode(cimgui::ImGuiWindow* window, cimgui::ImGuiDockNode* node, bool undock) +{ + ::ImGui::StartMouseMovingWindowOrNode(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiDockNode*>(node), undock); +} + +CIMGUI_API void cimgui::ImGui_StopMouseMovingWindow(void) +{ + ::ImGui::StopMouseMovingWindow(); +} + +CIMGUI_API void cimgui::ImGui_UpdateMouseMovingWindowNewFrame(void) +{ + ::ImGui::UpdateMouseMovingWindowNewFrame(); +} + +CIMGUI_API void cimgui::ImGui_UpdateMouseMovingWindowEndFrame(void) +{ + ::ImGui::UpdateMouseMovingWindowEndFrame(); +} + +CIMGUI_API ImGuiID cimgui::ImGui_AddContextHook(cimgui::ImGuiContext* context, const cimgui::ImGuiContextHook* hook) +{ + return ::ImGui::AddContextHook(reinterpret_cast<::ImGuiContext*>(context), reinterpret_cast(hook)); +} + +CIMGUI_API void cimgui::ImGui_RemoveContextHook(cimgui::ImGuiContext* context, ImGuiID hook_to_remove) +{ + ::ImGui::RemoveContextHook(reinterpret_cast<::ImGuiContext*>(context), hook_to_remove); +} + +CIMGUI_API void cimgui::ImGui_CallContextHooks(cimgui::ImGuiContext* context, cimgui::ImGuiContextHookType type) +{ + ::ImGui::CallContextHooks(reinterpret_cast<::ImGuiContext*>(context), static_cast<::ImGuiContextHookType>(type)); +} + +CIMGUI_API void cimgui::ImGui_TranslateWindowsInViewport(cimgui::ImGuiViewportP* viewport, cimgui::ImVec2 old_pos, cimgui::ImVec2 new_pos, cimgui::ImVec2 old_size, cimgui::ImVec2 new_size) +{ + ::ImGui::TranslateWindowsInViewport(reinterpret_cast<::ImGuiViewportP*>(viewport), ConvertToCPP_ImVec2(old_pos), ConvertToCPP_ImVec2(new_pos), ConvertToCPP_ImVec2(old_size), ConvertToCPP_ImVec2(new_size)); +} + +CIMGUI_API void cimgui::ImGui_ScaleWindowsInViewport(cimgui::ImGuiViewportP* viewport, float scale) +{ + ::ImGui::ScaleWindowsInViewport(reinterpret_cast<::ImGuiViewportP*>(viewport), scale); +} + +CIMGUI_API void cimgui::ImGui_DestroyPlatformWindow(cimgui::ImGuiViewportP* viewport) +{ + ::ImGui::DestroyPlatformWindow(reinterpret_cast<::ImGuiViewportP*>(viewport)); +} + +CIMGUI_API void cimgui::ImGui_SetWindowViewport(cimgui::ImGuiWindow* window, cimgui::ImGuiViewportP* viewport) +{ + ::ImGui::SetWindowViewport(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiViewportP*>(viewport)); +} + +CIMGUI_API void cimgui::ImGui_SetCurrentViewport(cimgui::ImGuiWindow* window, cimgui::ImGuiViewportP* viewport) +{ + ::ImGui::SetCurrentViewport(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiViewportP*>(viewport)); +} + +CIMGUI_API const cimgui::ImGuiPlatformMonitor* cimgui::ImGui_GetViewportPlatformMonitor(cimgui::ImGuiViewport* viewport) +{ + return reinterpret_cast(::ImGui::GetViewportPlatformMonitor(reinterpret_cast<::ImGuiViewport*>(viewport))); +} + +CIMGUI_API cimgui::ImGuiViewportP* cimgui::ImGui_FindHoveredViewportFromPlatformWindowStack(cimgui::ImVec2 mouse_platform_pos) +{ + return reinterpret_cast<::cimgui::ImGuiViewportP*>(::ImGui::FindHoveredViewportFromPlatformWindowStack(ConvertToCPP_ImVec2(mouse_platform_pos))); +} + +CIMGUI_API void cimgui::ImGui_MarkIniSettingsDirty(void) +{ + ::ImGui::MarkIniSettingsDirty(); +} + +CIMGUI_API void cimgui::ImGui_MarkIniSettingsDirtyImGuiWindowPtr(cimgui::ImGuiWindow* window) +{ + ::ImGui::MarkIniSettingsDirty(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_ClearIniSettings(void) +{ + ::ImGui::ClearIniSettings(); +} + +CIMGUI_API void cimgui::ImGui_AddSettingsHandler(const cimgui::ImGuiSettingsHandler* handler) +{ + ::ImGui::AddSettingsHandler(reinterpret_cast(handler)); +} + +CIMGUI_API void cimgui::ImGui_RemoveSettingsHandler(const char* type_name) +{ + ::ImGui::RemoveSettingsHandler(type_name); +} + +CIMGUI_API cimgui::ImGuiSettingsHandler* cimgui::ImGui_FindSettingsHandler(const char* type_name) +{ + return reinterpret_cast<::cimgui::ImGuiSettingsHandler*>(::ImGui::FindSettingsHandler(type_name)); +} + +CIMGUI_API cimgui::ImGuiWindowSettings* cimgui::ImGui_CreateNewWindowSettings(const char* name) +{ + return reinterpret_cast<::cimgui::ImGuiWindowSettings*>(::ImGui::CreateNewWindowSettings(name)); +} + +CIMGUI_API cimgui::ImGuiWindowSettings* cimgui::ImGui_FindWindowSettingsByID(ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiWindowSettings*>(::ImGui::FindWindowSettingsByID(id)); +} + +CIMGUI_API cimgui::ImGuiWindowSettings* cimgui::ImGui_FindWindowSettingsByWindow(cimgui::ImGuiWindow* window) +{ + return reinterpret_cast<::cimgui::ImGuiWindowSettings*>(::ImGui::FindWindowSettingsByWindow(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API void cimgui::ImGui_ClearWindowSettings(const char* name) +{ + ::ImGui::ClearWindowSettings(name); +} + +CIMGUI_API void cimgui::ImGui_LocalizeRegisterEntries(const cimgui::ImGuiLocEntry* entries, int count) +{ + ::ImGui::LocalizeRegisterEntries(reinterpret_cast(entries), count); +} + +CIMGUI_API const char* cimgui::ImGui_LocalizeGetMsg(cimgui::ImGuiLocKey key) +{ + return ::ImGui::LocalizeGetMsg(static_cast<::ImGuiLocKey>(key)); +} + +CIMGUI_API void cimgui::ImGui_SetScrollXImGuiWindowPtr(cimgui::ImGuiWindow* window, float scroll_x) +{ + ::ImGui::SetScrollX(reinterpret_cast<::ImGuiWindow*>(window), scroll_x); +} + +CIMGUI_API void cimgui::ImGui_SetScrollYImGuiWindowPtr(cimgui::ImGuiWindow* window, float scroll_y) +{ + ::ImGui::SetScrollY(reinterpret_cast<::ImGuiWindow*>(window), scroll_y); +} + +CIMGUI_API void cimgui::ImGui_SetScrollFromPosXImGuiWindowPtr(cimgui::ImGuiWindow* window, float local_x, float center_x_ratio) +{ + ::ImGui::SetScrollFromPosX(reinterpret_cast<::ImGuiWindow*>(window), local_x, center_x_ratio); +} + +CIMGUI_API void cimgui::ImGui_SetScrollFromPosYImGuiWindowPtr(cimgui::ImGuiWindow* window, float local_y, float center_y_ratio) +{ + ::ImGui::SetScrollFromPosY(reinterpret_cast<::ImGuiWindow*>(window), local_y, center_y_ratio); +} + +CIMGUI_API void cimgui::ImGui_ScrollToItem(ImGuiScrollFlags flags) +{ + ::ImGui::ScrollToItem(flags); +} + +CIMGUI_API void cimgui::ImGui_ScrollToRect(cimgui::ImGuiWindow* window, cimgui::ImRect rect, ImGuiScrollFlags flags) +{ + ::ImGui::ScrollToRect(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(rect), flags); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_ScrollToRectEx(cimgui::ImGuiWindow* window, cimgui::ImRect rect, ImGuiScrollFlags flags) +{ + return ConvertFromCPP_ImVec2(::ImGui::ScrollToRectEx(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(rect), flags)); +} + +CIMGUI_API void cimgui::ImGui_ScrollToBringRectIntoView(cimgui::ImGuiWindow* window, cimgui::ImRect rect) +{ + ::ImGui::ScrollToBringRectIntoView(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(rect)); +} + +CIMGUI_API ImGuiItemStatusFlags cimgui::ImGui_GetItemStatusFlags(void) +{ + return ::ImGui::GetItemStatusFlags(); +} + +CIMGUI_API ImGuiItemFlags cimgui::ImGui_GetItemFlags(void) +{ + return ::ImGui::GetItemFlags(); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetActiveID(void) +{ + return ::ImGui::GetActiveID(); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetFocusID(void) +{ + return ::ImGui::GetFocusID(); +} + +CIMGUI_API void cimgui::ImGui_SetActiveID(ImGuiID id, cimgui::ImGuiWindow* window) +{ + ::ImGui::SetActiveID(id, reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_SetFocusID(ImGuiID id, cimgui::ImGuiWindow* window) +{ + ::ImGui::SetFocusID(id, reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_ClearActiveID(void) +{ + ::ImGui::ClearActiveID(); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetHoveredID(void) +{ + return ::ImGui::GetHoveredID(); +} + +CIMGUI_API void cimgui::ImGui_SetHoveredID(ImGuiID id) +{ + ::ImGui::SetHoveredID(id); +} + +CIMGUI_API void cimgui::ImGui_KeepAliveID(ImGuiID id) +{ + ::ImGui::KeepAliveID(id); +} + +CIMGUI_API void cimgui::ImGui_MarkItemEdited(ImGuiID id) +{ + ::ImGui::MarkItemEdited(id); +} + +CIMGUI_API void cimgui::ImGui_PushOverrideID(ImGuiID id) +{ + ::ImGui::PushOverrideID(id); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetIDWithSeedStr(const char* str_id_begin, const char* str_id_end, ImGuiID seed) +{ + return ::ImGui::GetIDWithSeed(str_id_begin, str_id_end, seed); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetIDWithSeed(int n, ImGuiID seed) +{ + return ::ImGui::GetIDWithSeed(n, seed); +} + +CIMGUI_API void cimgui::ImGui_ItemSize(cimgui::ImVec2 size) +{ + ::ImGui::ItemSize(ConvertToCPP_ImVec2(size)); +} + +CIMGUI_API void cimgui::ImGui_ItemSizeEx(cimgui::ImVec2 size, float text_baseline_y) +{ + ::ImGui::ItemSize(ConvertToCPP_ImVec2(size), text_baseline_y); +} + +CIMGUI_API void cimgui::ImGui_ItemSizeImRect(cimgui::ImRect bb) +{ + ::ImGui::ItemSize(ConvertToCPP_ImRect(bb)); +} + +CIMGUI_API void cimgui::ImGui_ItemSizeImRectEx(cimgui::ImRect bb, float text_baseline_y) +{ + ::ImGui::ItemSize(ConvertToCPP_ImRect(bb), text_baseline_y); +} + +CIMGUI_API bool cimgui::ImGui_ItemAdd(cimgui::ImRect bb, ImGuiID id) +{ + return ::ImGui::ItemAdd(ConvertToCPP_ImRect(bb), id); +} + +CIMGUI_API bool cimgui::ImGui_ItemAddEx(cimgui::ImRect bb, ImGuiID id, const cimgui::ImRect* nav_bb, ImGuiItemFlags extra_flags) +{ + return ::ImGui::ItemAdd(ConvertToCPP_ImRect(bb), id, reinterpret_cast(nav_bb), extra_flags); +} + +CIMGUI_API bool cimgui::ImGui_ItemHoverable(cimgui::ImRect bb, ImGuiID id, ImGuiItemFlags item_flags) +{ + return ::ImGui::ItemHoverable(ConvertToCPP_ImRect(bb), id, item_flags); +} + +CIMGUI_API bool cimgui::ImGui_IsWindowContentHoverable(cimgui::ImGuiWindow* window, ImGuiHoveredFlags flags) +{ + return ::ImGui::IsWindowContentHoverable(reinterpret_cast<::ImGuiWindow*>(window), flags); +} + +CIMGUI_API bool cimgui::ImGui_IsClippedEx(cimgui::ImRect bb, ImGuiID id) +{ + return ::ImGui::IsClippedEx(ConvertToCPP_ImRect(bb), id); +} + +CIMGUI_API void cimgui::ImGui_SetLastItemData(ImGuiID item_id, ImGuiItemFlags item_flags, ImGuiItemStatusFlags status_flags, cimgui::ImRect item_rect) +{ + ::ImGui::SetLastItemData(item_id, item_flags, status_flags, ConvertToCPP_ImRect(item_rect)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_CalcItemSize(cimgui::ImVec2 size, float default_w, float default_h) +{ + return ConvertFromCPP_ImVec2(::ImGui::CalcItemSize(ConvertToCPP_ImVec2(size), default_w, default_h)); +} + +CIMGUI_API float cimgui::ImGui_CalcWrapWidthForPos(cimgui::ImVec2 pos, float wrap_pos_x) +{ + return ::ImGui::CalcWrapWidthForPos(ConvertToCPP_ImVec2(pos), wrap_pos_x); +} + +CIMGUI_API void cimgui::ImGui_PushMultiItemsWidths(int components, float width_full) +{ + ::ImGui::PushMultiItemsWidths(components, width_full); +} + +CIMGUI_API void cimgui::ImGui_ShrinkWidths(cimgui::ImGuiShrinkWidthItem* items, int count, float width_excess, float width_min) +{ + ::ImGui::ShrinkWidths(reinterpret_cast<::ImGuiShrinkWidthItem*>(items), count, width_excess, width_min); +} + +CIMGUI_API const cimgui::ImGuiStyleVarInfo* cimgui::ImGui_GetStyleVarInfo(ImGuiStyleVar idx) +{ + return reinterpret_cast(::ImGui::GetStyleVarInfo(idx)); +} + +CIMGUI_API void cimgui::ImGui_BeginDisabledOverrideReenable(void) +{ + ::ImGui::BeginDisabledOverrideReenable(); +} + +CIMGUI_API void cimgui::ImGui_EndDisabledOverrideReenable(void) +{ + ::ImGui::EndDisabledOverrideReenable(); +} + +CIMGUI_API void cimgui::ImGui_LogBegin(ImGuiLogFlags flags, int auto_open_depth) +{ + ::ImGui::LogBegin(flags, auto_open_depth); +} + +CIMGUI_API void cimgui::ImGui_LogToBuffer(void) +{ + ::ImGui::LogToBuffer(); +} + +CIMGUI_API void cimgui::ImGui_LogToBufferEx(int auto_open_depth) +{ + ::ImGui::LogToBuffer(auto_open_depth); +} + +CIMGUI_API void cimgui::ImGui_LogRenderedText(const cimgui::ImVec2* ref_pos, const char* text) +{ + ::ImGui::LogRenderedText(reinterpret_cast(ref_pos), text); +} + +CIMGUI_API void cimgui::ImGui_LogRenderedTextEx(const cimgui::ImVec2* ref_pos, const char* text, const char* text_end) +{ + ::ImGui::LogRenderedText(reinterpret_cast(ref_pos), text, text_end); +} + +CIMGUI_API void cimgui::ImGui_LogSetNextTextDecoration(const char* prefix, const char* suffix) +{ + ::ImGui::LogSetNextTextDecoration(prefix, suffix); +} + +CIMGUI_API bool cimgui::ImGui_BeginChildEx(const char* name, ImGuiID id, cimgui::ImVec2 size_arg, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags) +{ + return ::ImGui::BeginChildEx(name, id, ConvertToCPP_ImVec2(size_arg), child_flags, window_flags); +} + +CIMGUI_API bool cimgui::ImGui_BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_window_flags) +{ + return ::ImGui::BeginPopupEx(id, extra_window_flags); +} + +CIMGUI_API bool cimgui::ImGui_BeginPopupMenuEx(ImGuiID id, const char* label, ImGuiWindowFlags extra_window_flags) +{ + return ::ImGui::BeginPopupMenuEx(id, label, extra_window_flags); +} + +CIMGUI_API void cimgui::ImGui_OpenPopupEx(ImGuiID id) +{ + ::ImGui::OpenPopupEx(id); +} + +CIMGUI_API void cimgui::ImGui_OpenPopupExEx(ImGuiID id, ImGuiPopupFlags popup_flags) +{ + ::ImGui::OpenPopupEx(id, popup_flags); +} + +CIMGUI_API void cimgui::ImGui_ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup) +{ + ::ImGui::ClosePopupToLevel(remaining, restore_focus_to_window_under_popup); +} + +CIMGUI_API void cimgui::ImGui_ClosePopupsOverWindow(cimgui::ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup) +{ + ::ImGui::ClosePopupsOverWindow(reinterpret_cast<::ImGuiWindow*>(ref_window), restore_focus_to_window_under_popup); +} + +CIMGUI_API void cimgui::ImGui_ClosePopupsExceptModals(void) +{ + ::ImGui::ClosePopupsExceptModals(); +} + +CIMGUI_API bool cimgui::ImGui_IsPopupOpenID(ImGuiID id, ImGuiPopupFlags popup_flags) +{ + return ::ImGui::IsPopupOpen(id, popup_flags); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGui_GetPopupAllowedExtentRect(cimgui::ImGuiWindow* window) +{ + return ConvertFromCPP_ImRect(::ImGui::GetPopupAllowedExtentRect(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetTopMostPopupModal(void) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetTopMostPopupModal()); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetTopMostAndVisiblePopupModal(void) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetTopMostAndVisiblePopupModal()); +} + +CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindBlockingModal(cimgui::ImGuiWindow* window) +{ + return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindBlockingModal(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_FindBestWindowPosForPopup(cimgui::ImGuiWindow* window) +{ + return ConvertFromCPP_ImVec2(::ImGui::FindBestWindowPosForPopup(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_FindBestWindowPosForPopupEx(cimgui::ImVec2 ref_pos, cimgui::ImVec2 size, cimgui::ImGuiDir* last_dir, cimgui::ImRect r_outer, cimgui::ImRect r_avoid, cimgui::ImGuiPopupPositionPolicy policy) +{ + return ConvertFromCPP_ImVec2(::ImGui::FindBestWindowPosForPopupEx(ConvertToCPP_ImVec2(ref_pos), ConvertToCPP_ImVec2(size), reinterpret_cast<::ImGuiDir*>(last_dir), ConvertToCPP_ImRect(r_outer), ConvertToCPP_ImRect(r_avoid), static_cast<::ImGuiPopupPositionPolicy>(policy))); +} + +CIMGUI_API bool cimgui::ImGui_BeginTooltipEx(ImGuiTooltipFlags tooltip_flags, ImGuiWindowFlags extra_window_flags) +{ + return ::ImGui::BeginTooltipEx(tooltip_flags, extra_window_flags); +} + +CIMGUI_API bool cimgui::ImGui_BeginTooltipHidden(void) +{ + return ::ImGui::BeginTooltipHidden(); +} + +CIMGUI_API bool cimgui::ImGui_BeginViewportSideBar(const char* name, cimgui::ImGuiViewport* viewport, cimgui::ImGuiDir dir, float size, ImGuiWindowFlags window_flags) +{ + return ::ImGui::BeginViewportSideBar(name, reinterpret_cast<::ImGuiViewport*>(viewport), static_cast<::ImGuiDir>(dir), size, window_flags); +} + +CIMGUI_API bool cimgui::ImGui_BeginMenuWithIcon(const char* label, const char* icon) +{ + return ::ImGui::BeginMenuEx(label, icon); +} + +CIMGUI_API bool cimgui::ImGui_BeginMenuWithIconEx(const char* label, const char* icon, bool enabled) +{ + return ::ImGui::BeginMenuEx(label, icon, enabled); +} + +CIMGUI_API bool cimgui::ImGui_MenuItemWithIcon(const char* label, const char* icon) +{ + return ::ImGui::MenuItemEx(label, icon); +} + +CIMGUI_API bool cimgui::ImGui_MenuItemWithIconEx(const char* label, const char* icon, const char* shortcut, bool selected, bool enabled) +{ + return ::ImGui::MenuItemEx(label, icon, shortcut, selected, enabled); +} + +CIMGUI_API bool cimgui::ImGui_BeginComboPopup(ImGuiID popup_id, cimgui::ImRect bb, ImGuiComboFlags flags) +{ + return ::ImGui::BeginComboPopup(popup_id, ConvertToCPP_ImRect(bb), flags); +} + +CIMGUI_API bool cimgui::ImGui_BeginComboPreview(void) +{ + return ::ImGui::BeginComboPreview(); +} + +CIMGUI_API void cimgui::ImGui_EndComboPreview(void) +{ + ::ImGui::EndComboPreview(); +} + +CIMGUI_API void cimgui::ImGui_NavInitWindow(cimgui::ImGuiWindow* window, bool force_reinit) +{ + ::ImGui::NavInitWindow(reinterpret_cast<::ImGuiWindow*>(window), force_reinit); +} + +CIMGUI_API void cimgui::ImGui_NavInitRequestApplyResult(void) +{ + ::ImGui::NavInitRequestApplyResult(); +} + +CIMGUI_API bool cimgui::ImGui_NavMoveRequestButNoResultYet(void) +{ + return ::ImGui::NavMoveRequestButNoResultYet(); +} + +CIMGUI_API void cimgui::ImGui_NavMoveRequestSubmit(cimgui::ImGuiDir move_dir, cimgui::ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags) +{ + ::ImGui::NavMoveRequestSubmit(static_cast<::ImGuiDir>(move_dir), static_cast<::ImGuiDir>(clip_dir), move_flags, scroll_flags); +} + +CIMGUI_API void cimgui::ImGui_NavMoveRequestForward(cimgui::ImGuiDir move_dir, cimgui::ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags) +{ + ::ImGui::NavMoveRequestForward(static_cast<::ImGuiDir>(move_dir), static_cast<::ImGuiDir>(clip_dir), move_flags, scroll_flags); +} + +CIMGUI_API void cimgui::ImGui_NavMoveRequestResolveWithLastItem(cimgui::ImGuiNavItemData* result) +{ + ::ImGui::NavMoveRequestResolveWithLastItem(reinterpret_cast<::ImGuiNavItemData*>(result)); +} + +CIMGUI_API void cimgui::ImGui_NavMoveRequestResolveWithPastTreeNode(cimgui::ImGuiNavItemData* result, const cimgui::ImGuiTreeNodeStackData* tree_node_data) +{ + ::ImGui::NavMoveRequestResolveWithPastTreeNode(reinterpret_cast<::ImGuiNavItemData*>(result), reinterpret_cast(tree_node_data)); +} + +CIMGUI_API void cimgui::ImGui_NavMoveRequestCancel(void) +{ + ::ImGui::NavMoveRequestCancel(); +} + +CIMGUI_API void cimgui::ImGui_NavMoveRequestApplyResult(void) +{ + ::ImGui::NavMoveRequestApplyResult(); +} + +CIMGUI_API void cimgui::ImGui_NavMoveRequestTryWrapping(cimgui::ImGuiWindow* window, ImGuiNavMoveFlags move_flags) +{ + ::ImGui::NavMoveRequestTryWrapping(reinterpret_cast<::ImGuiWindow*>(window), move_flags); +} + +CIMGUI_API void cimgui::ImGui_NavHighlightActivated(ImGuiID id) +{ + ::ImGui::NavHighlightActivated(id); +} + +CIMGUI_API void cimgui::ImGui_NavClearPreferredPosForAxis(cimgui::ImGuiAxis axis) +{ + ::ImGui::NavClearPreferredPosForAxis(static_cast<::ImGuiAxis>(axis)); +} + +CIMGUI_API void cimgui::ImGui_SetNavCursorVisibleAfterMove(void) +{ + ::ImGui::SetNavCursorVisibleAfterMove(); +} + +CIMGUI_API void cimgui::ImGui_NavUpdateCurrentWindowIsScrollPushableX(void) +{ + ::ImGui::NavUpdateCurrentWindowIsScrollPushableX(); +} + +CIMGUI_API void cimgui::ImGui_SetNavWindow(cimgui::ImGuiWindow* window) +{ + ::ImGui::SetNavWindow(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_SetNavID(ImGuiID id, cimgui::ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, cimgui::ImRect rect_rel) +{ + ::ImGui::SetNavID(id, static_cast<::ImGuiNavLayer>(nav_layer), focus_scope_id, ConvertToCPP_ImRect(rect_rel)); +} + +CIMGUI_API void cimgui::ImGui_SetNavFocusScope(ImGuiID focus_scope_id) +{ + ::ImGui::SetNavFocusScope(focus_scope_id); +} + +CIMGUI_API void cimgui::ImGui_FocusItem(void) +{ + ::ImGui::FocusItem(); +} + +CIMGUI_API void cimgui::ImGui_ActivateItemByID(ImGuiID id) +{ + ::ImGui::ActivateItemByID(id); +} + +CIMGUI_API bool cimgui::ImGui_IsNamedKey(cimgui::ImGuiKey key) +{ + return ::ImGui::IsNamedKey(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API bool cimgui::ImGui_IsNamedKeyOrMod(cimgui::ImGuiKey key) +{ + return ::ImGui::IsNamedKeyOrMod(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API bool cimgui::ImGui_IsLegacyKey(cimgui::ImGuiKey key) +{ + return ::ImGui::IsLegacyKey(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API bool cimgui::ImGui_IsKeyboardKey(cimgui::ImGuiKey key) +{ + return ::ImGui::IsKeyboardKey(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API bool cimgui::ImGui_IsGamepadKey(cimgui::ImGuiKey key) +{ + return ::ImGui::IsGamepadKey(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseKey(cimgui::ImGuiKey key) +{ + return ::ImGui::IsMouseKey(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API bool cimgui::ImGui_IsAliasKey(cimgui::ImGuiKey key) +{ + return ::ImGui::IsAliasKey(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API bool cimgui::ImGui_IsLRModKey(cimgui::ImGuiKey key) +{ + return ::ImGui::IsLRModKey(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API ImGuiKeyChord cimgui::ImGui_FixupKeyChord(ImGuiKeyChord key_chord) +{ + return ::ImGui::FixupKeyChord(key_chord); +} + +CIMGUI_API cimgui::ImGuiKey cimgui::ImGui_ConvertSingleModFlagToKey(cimgui::ImGuiKey key) +{ + return static_cast<::cimgui::ImGuiKey>(::ImGui::ConvertSingleModFlagToKey(static_cast<::ImGuiKey>(key))); +} + +CIMGUI_API cimgui::ImGuiKeyData* cimgui::ImGui_GetKeyDataImGuiContextPtr(cimgui::ImGuiContext* ctx, cimgui::ImGuiKey key) +{ + return reinterpret_cast<::cimgui::ImGuiKeyData*>(::ImGui::GetKeyData(reinterpret_cast<::ImGuiContext*>(ctx), static_cast<::ImGuiKey>(key))); +} + +CIMGUI_API cimgui::ImGuiKeyData* cimgui::ImGui_GetKeyData(cimgui::ImGuiKey key) +{ + return reinterpret_cast<::cimgui::ImGuiKeyData*>(::ImGui::GetKeyData(static_cast<::ImGuiKey>(key))); +} + +CIMGUI_API const char* cimgui::ImGui_GetKeyChordName(ImGuiKeyChord key_chord) +{ + return ::ImGui::GetKeyChordName(key_chord); +} + +CIMGUI_API cimgui::ImGuiKey cimgui::ImGui_MouseButtonToKey(ImGuiMouseButton button) +{ + return static_cast<::cimgui::ImGuiKey>(::ImGui::MouseButtonToKey(button)); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseDragPastThreshold(ImGuiMouseButton button) +{ + return ::ImGui::IsMouseDragPastThreshold(button); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseDragPastThresholdEx(ImGuiMouseButton button, float lock_threshold) +{ + return ::ImGui::IsMouseDragPastThreshold(button, lock_threshold); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetKeyMagnitude2d(cimgui::ImGuiKey key_left, cimgui::ImGuiKey key_right, cimgui::ImGuiKey key_up, cimgui::ImGuiKey key_down) +{ + return ConvertFromCPP_ImVec2(::ImGui::GetKeyMagnitude2d(static_cast<::ImGuiKey>(key_left), static_cast<::ImGuiKey>(key_right), static_cast<::ImGuiKey>(key_up), static_cast<::ImGuiKey>(key_down))); +} + +CIMGUI_API float cimgui::ImGui_GetNavTweakPressedAmount(cimgui::ImGuiAxis axis) +{ + return ::ImGui::GetNavTweakPressedAmount(static_cast<::ImGuiAxis>(axis)); +} + +CIMGUI_API int cimgui::ImGui_CalcTypematicRepeatAmount(float t0, float t1, float repeat_delay, float repeat_rate) +{ + return ::ImGui::CalcTypematicRepeatAmount(t0, t1, repeat_delay, repeat_rate); +} + +CIMGUI_API void cimgui::ImGui_GetTypematicRepeatRate(ImGuiInputFlags flags, float* repeat_delay, float* repeat_rate) +{ + ::ImGui::GetTypematicRepeatRate(flags, repeat_delay, repeat_rate); +} + +CIMGUI_API void cimgui::ImGui_TeleportMousePos(cimgui::ImVec2 pos) +{ + ::ImGui::TeleportMousePos(ConvertToCPP_ImVec2(pos)); +} + +CIMGUI_API void cimgui::ImGui_SetActiveIdUsingAllKeyboardKeys(void) +{ + ::ImGui::SetActiveIdUsingAllKeyboardKeys(); +} + +CIMGUI_API bool cimgui::ImGui_IsActiveIdUsingNavDir(cimgui::ImGuiDir dir) +{ + return ::ImGui::IsActiveIdUsingNavDir(static_cast<::ImGuiDir>(dir)); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetKeyOwner(cimgui::ImGuiKey key) +{ + return ::ImGui::GetKeyOwner(static_cast<::ImGuiKey>(key)); +} + +CIMGUI_API void cimgui::ImGui_SetKeyOwner(cimgui::ImGuiKey key, ImGuiID owner_id, ImGuiInputFlags flags) +{ + ::ImGui::SetKeyOwner(static_cast<::ImGuiKey>(key), owner_id, flags); +} + +CIMGUI_API void cimgui::ImGui_SetKeyOwnersForKeyChord(ImGuiKeyChord key, ImGuiID owner_id, ImGuiInputFlags flags) +{ + ::ImGui::SetKeyOwnersForKeyChord(key, owner_id, flags); +} + +CIMGUI_API void cimgui::ImGui_SetItemKeyOwnerImGuiInputFlags(cimgui::ImGuiKey key, ImGuiInputFlags flags) +{ + ::ImGui::SetItemKeyOwner(static_cast<::ImGuiKey>(key), flags); +} + +CIMGUI_API bool cimgui::ImGui_TestKeyOwner(cimgui::ImGuiKey key, ImGuiID owner_id) +{ + return ::ImGui::TestKeyOwner(static_cast<::ImGuiKey>(key), owner_id); +} + +CIMGUI_API cimgui::ImGuiKeyOwnerData* cimgui::ImGui_GetKeyOwnerData(cimgui::ImGuiContext* ctx, cimgui::ImGuiKey key) +{ + return reinterpret_cast<::cimgui::ImGuiKeyOwnerData*>(::ImGui::GetKeyOwnerData(reinterpret_cast<::ImGuiContext*>(ctx), static_cast<::ImGuiKey>(key))); +} + +CIMGUI_API bool cimgui::ImGui_IsKeyDownID(cimgui::ImGuiKey key, ImGuiID owner_id) +{ + return ::ImGui::IsKeyDown(static_cast<::ImGuiKey>(key), owner_id); +} + +CIMGUI_API bool cimgui::ImGui_IsKeyPressedImGuiInputFlags(cimgui::ImGuiKey key, ImGuiInputFlags flags) +{ + return ::ImGui::IsKeyPressed(static_cast<::ImGuiKey>(key), flags); +} + +CIMGUI_API bool cimgui::ImGui_IsKeyPressedImGuiInputFlagsEx(cimgui::ImGuiKey key, ImGuiInputFlags flags, ImGuiID owner_id) +{ + return ::ImGui::IsKeyPressed(static_cast<::ImGuiKey>(key), flags, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_IsKeyReleasedID(cimgui::ImGuiKey key, ImGuiID owner_id) +{ + return ::ImGui::IsKeyReleased(static_cast<::ImGuiKey>(key), owner_id); +} + +CIMGUI_API bool cimgui::ImGui_IsKeyChordPressedImGuiInputFlags(ImGuiKeyChord key_chord, ImGuiInputFlags flags) +{ + return ::ImGui::IsKeyChordPressed(key_chord, flags); +} + +CIMGUI_API bool cimgui::ImGui_IsKeyChordPressedImGuiInputFlagsEx(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id) +{ + return ::ImGui::IsKeyChordPressed(key_chord, flags, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseDownID(ImGuiMouseButton button, ImGuiID owner_id) +{ + return ::ImGui::IsMouseDown(button, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseClickedImGuiInputFlags(ImGuiMouseButton button, ImGuiInputFlags flags) +{ + return ::ImGui::IsMouseClicked(button, flags); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseClickedImGuiInputFlagsEx(ImGuiMouseButton button, ImGuiInputFlags flags, ImGuiID owner_id) +{ + return ::ImGui::IsMouseClicked(button, flags, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseReleasedID(ImGuiMouseButton button, ImGuiID owner_id) +{ + return ::ImGui::IsMouseReleased(button, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_IsMouseDoubleClickedID(ImGuiMouseButton button, ImGuiID owner_id) +{ + return ::ImGui::IsMouseDoubleClicked(button, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_ShortcutID(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id) +{ + return ::ImGui::Shortcut(key_chord, flags, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_SetShortcutRouting(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id) +{ + return ::ImGui::SetShortcutRouting(key_chord, flags, owner_id); +} + +CIMGUI_API bool cimgui::ImGui_TestShortcutRouting(ImGuiKeyChord key_chord, ImGuiID owner_id) +{ + return ::ImGui::TestShortcutRouting(key_chord, owner_id); +} + +CIMGUI_API cimgui::ImGuiKeyRoutingData* cimgui::ImGui_GetShortcutRoutingData(ImGuiKeyChord key_chord) +{ + return reinterpret_cast<::cimgui::ImGuiKeyRoutingData*>(::ImGui::GetShortcutRoutingData(key_chord)); +} + +CIMGUI_API void cimgui::ImGui_DockContextInitialize(cimgui::ImGuiContext* ctx) +{ + ::ImGui::DockContextInitialize(reinterpret_cast<::ImGuiContext*>(ctx)); +} + +CIMGUI_API void cimgui::ImGui_DockContextShutdown(cimgui::ImGuiContext* ctx) +{ + ::ImGui::DockContextShutdown(reinterpret_cast<::ImGuiContext*>(ctx)); +} + +CIMGUI_API void cimgui::ImGui_DockContextClearNodes(cimgui::ImGuiContext* ctx, ImGuiID root_id, bool clear_settings_refs) +{ + ::ImGui::DockContextClearNodes(reinterpret_cast<::ImGuiContext*>(ctx), root_id, clear_settings_refs); +} + +CIMGUI_API void cimgui::ImGui_DockContextRebuildNodes(cimgui::ImGuiContext* ctx) +{ + ::ImGui::DockContextRebuildNodes(reinterpret_cast<::ImGuiContext*>(ctx)); +} + +CIMGUI_API void cimgui::ImGui_DockContextNewFrameUpdateUndocking(cimgui::ImGuiContext* ctx) +{ + ::ImGui::DockContextNewFrameUpdateUndocking(reinterpret_cast<::ImGuiContext*>(ctx)); +} + +CIMGUI_API void cimgui::ImGui_DockContextNewFrameUpdateDocking(cimgui::ImGuiContext* ctx) +{ + ::ImGui::DockContextNewFrameUpdateDocking(reinterpret_cast<::ImGuiContext*>(ctx)); +} + +CIMGUI_API void cimgui::ImGui_DockContextEndFrame(cimgui::ImGuiContext* ctx) +{ + ::ImGui::DockContextEndFrame(reinterpret_cast<::ImGuiContext*>(ctx)); +} + +CIMGUI_API ImGuiID cimgui::ImGui_DockContextGenNodeID(cimgui::ImGuiContext* ctx) +{ + return ::ImGui::DockContextGenNodeID(reinterpret_cast<::ImGuiContext*>(ctx)); +} + +CIMGUI_API void cimgui::ImGui_DockContextQueueDock(cimgui::ImGuiContext* ctx, cimgui::ImGuiWindow* target, cimgui::ImGuiDockNode* target_node, cimgui::ImGuiWindow* payload, cimgui::ImGuiDir split_dir, float split_ratio, bool split_outer) +{ + ::ImGui::DockContextQueueDock(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiWindow*>(target), reinterpret_cast<::ImGuiDockNode*>(target_node), reinterpret_cast<::ImGuiWindow*>(payload), static_cast<::ImGuiDir>(split_dir), split_ratio, split_outer); +} + +CIMGUI_API void cimgui::ImGui_DockContextQueueUndockWindow(cimgui::ImGuiContext* ctx, cimgui::ImGuiWindow* window) +{ + ::ImGui::DockContextQueueUndockWindow(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_DockContextQueueUndockNode(cimgui::ImGuiContext* ctx, cimgui::ImGuiDockNode* node) +{ + ::ImGui::DockContextQueueUndockNode(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiDockNode*>(node)); +} + +CIMGUI_API void cimgui::ImGui_DockContextProcessUndockWindow(cimgui::ImGuiContext* ctx, cimgui::ImGuiWindow* window) +{ + ::ImGui::DockContextProcessUndockWindow(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_DockContextProcessUndockWindowEx(cimgui::ImGuiContext* ctx, cimgui::ImGuiWindow* window, bool clear_persistent_docking_ref) +{ + ::ImGui::DockContextProcessUndockWindow(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiWindow*>(window), clear_persistent_docking_ref); +} + +CIMGUI_API void cimgui::ImGui_DockContextProcessUndockNode(cimgui::ImGuiContext* ctx, cimgui::ImGuiDockNode* node) +{ + ::ImGui::DockContextProcessUndockNode(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiDockNode*>(node)); +} + +CIMGUI_API bool cimgui::ImGui_DockContextCalcDropPosForDocking(cimgui::ImGuiWindow* target, cimgui::ImGuiDockNode* target_node, cimgui::ImGuiWindow* payload_window, cimgui::ImGuiDockNode* payload_node, cimgui::ImGuiDir split_dir, bool split_outer, cimgui::ImVec2* out_pos) +{ + return ::ImGui::DockContextCalcDropPosForDocking(reinterpret_cast<::ImGuiWindow*>(target), reinterpret_cast<::ImGuiDockNode*>(target_node), reinterpret_cast<::ImGuiWindow*>(payload_window), reinterpret_cast<::ImGuiDockNode*>(payload_node), static_cast<::ImGuiDir>(split_dir), split_outer, reinterpret_cast<::ImVec2*>(out_pos)); +} + +CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockContextFindNodeByID(cimgui::ImGuiContext* ctx, ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockContextFindNodeByID(reinterpret_cast<::ImGuiContext*>(ctx), id)); +} + +CIMGUI_API void cimgui::ImGui_DockNodeWindowMenuHandler_Default(cimgui::ImGuiContext* ctx, cimgui::ImGuiDockNode* node, cimgui::ImGuiTabBar* tab_bar) +{ + ::ImGui::DockNodeWindowMenuHandler_Default(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiDockNode*>(node), reinterpret_cast<::ImGuiTabBar*>(tab_bar)); +} + +CIMGUI_API bool cimgui::ImGui_DockNodeBeginAmendTabBar(cimgui::ImGuiDockNode* node) +{ + return ::ImGui::DockNodeBeginAmendTabBar(reinterpret_cast<::ImGuiDockNode*>(node)); +} + +CIMGUI_API void cimgui::ImGui_DockNodeEndAmendTabBar(void) +{ + ::ImGui::DockNodeEndAmendTabBar(); +} + +CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockNodeGetRootNode(cimgui::ImGuiDockNode* node) +{ + return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockNodeGetRootNode(reinterpret_cast<::ImGuiDockNode*>(node))); +} + +CIMGUI_API bool cimgui::ImGui_DockNodeIsInHierarchyOf(cimgui::ImGuiDockNode* node, cimgui::ImGuiDockNode* parent) +{ + return ::ImGui::DockNodeIsInHierarchyOf(reinterpret_cast<::ImGuiDockNode*>(node), reinterpret_cast<::ImGuiDockNode*>(parent)); +} + +CIMGUI_API int cimgui::ImGui_DockNodeGetDepth(const cimgui::ImGuiDockNode* node) +{ + return ::ImGui::DockNodeGetDepth(reinterpret_cast(node)); +} + +CIMGUI_API ImGuiID cimgui::ImGui_DockNodeGetWindowMenuButtonId(const cimgui::ImGuiDockNode* node) +{ + return ::ImGui::DockNodeGetWindowMenuButtonId(reinterpret_cast(node)); +} + +CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_GetWindowDockNode(void) +{ + return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::GetWindowDockNode()); +} + +CIMGUI_API bool cimgui::ImGui_GetWindowAlwaysWantOwnTabBar(cimgui::ImGuiWindow* window) +{ + return ::ImGui::GetWindowAlwaysWantOwnTabBar(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_BeginDocked(cimgui::ImGuiWindow* window, bool* p_open) +{ + ::ImGui::BeginDocked(reinterpret_cast<::ImGuiWindow*>(window), p_open); +} + +CIMGUI_API void cimgui::ImGui_BeginDockableDragDropSource(cimgui::ImGuiWindow* window) +{ + ::ImGui::BeginDockableDragDropSource(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_BeginDockableDragDropTarget(cimgui::ImGuiWindow* window) +{ + ::ImGui::BeginDockableDragDropTarget(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_SetWindowDock(cimgui::ImGuiWindow* window, ImGuiID dock_id, ImGuiCond cond) +{ + ::ImGui::SetWindowDock(reinterpret_cast<::ImGuiWindow*>(window), dock_id, cond); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderDockWindow(const char* window_name, ImGuiID node_id) +{ + ::ImGui::DockBuilderDockWindow(window_name, node_id); +} + +CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockBuilderGetNode(ImGuiID node_id) +{ + return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockBuilderGetNode(node_id)); +} + +CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockBuilderGetCentralNode(ImGuiID node_id) +{ + return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockBuilderGetCentralNode(node_id)); +} + +CIMGUI_API ImGuiID cimgui::ImGui_DockBuilderAddNode(void) +{ + return ::ImGui::DockBuilderAddNode(); +} + +CIMGUI_API ImGuiID cimgui::ImGui_DockBuilderAddNodeEx(ImGuiID node_id, ImGuiDockNodeFlags flags) +{ + return ::ImGui::DockBuilderAddNode(node_id, flags); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderRemoveNode(ImGuiID node_id) +{ + ::ImGui::DockBuilderRemoveNode(node_id); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderRemoveNodeDockedWindows(ImGuiID node_id) +{ + ::ImGui::DockBuilderRemoveNodeDockedWindows(node_id); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderRemoveNodeDockedWindowsEx(ImGuiID node_id, bool clear_settings_refs) +{ + ::ImGui::DockBuilderRemoveNodeDockedWindows(node_id, clear_settings_refs); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderRemoveNodeChildNodes(ImGuiID node_id) +{ + ::ImGui::DockBuilderRemoveNodeChildNodes(node_id); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderSetNodePos(ImGuiID node_id, cimgui::ImVec2 pos) +{ + ::ImGui::DockBuilderSetNodePos(node_id, ConvertToCPP_ImVec2(pos)); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderSetNodeSize(ImGuiID node_id, cimgui::ImVec2 size) +{ + ::ImGui::DockBuilderSetNodeSize(node_id, ConvertToCPP_ImVec2(size)); +} + +CIMGUI_API ImGuiID cimgui::ImGui_DockBuilderSplitNode(ImGuiID node_id, cimgui::ImGuiDir split_dir, float size_ratio_for_node_at_dir, ImGuiID* out_id_at_dir, ImGuiID* out_id_at_opposite_dir) +{ + return ::ImGui::DockBuilderSplitNode(node_id, static_cast<::ImGuiDir>(split_dir), size_ratio_for_node_at_dir, out_id_at_dir, out_id_at_opposite_dir); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderCopyDockSpace(ImGuiID src_dockspace_id, ImGuiID dst_dockspace_id, cimgui::ImVector_const_charPtr* in_window_remap_pairs) +{ + ::ImGui::DockBuilderCopyDockSpace(src_dockspace_id, dst_dockspace_id, reinterpret_cast<::ImVector*>(in_window_remap_pairs)); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderCopyNode(ImGuiID src_node_id, ImGuiID dst_node_id, cimgui::ImVector_ImGuiID* out_node_remap_pairs) +{ + ::ImGui::DockBuilderCopyNode(src_node_id, dst_node_id, reinterpret_cast<::ImVector<::ImGuiID>*>(out_node_remap_pairs)); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderCopyWindowSettings(const char* src_name, const char* dst_name) +{ + ::ImGui::DockBuilderCopyWindowSettings(src_name, dst_name); +} + +CIMGUI_API void cimgui::ImGui_DockBuilderFinish(ImGuiID node_id) +{ + ::ImGui::DockBuilderFinish(node_id); +} + +CIMGUI_API void cimgui::ImGui_PushFocusScope(ImGuiID id) +{ + ::ImGui::PushFocusScope(id); +} + +CIMGUI_API void cimgui::ImGui_PopFocusScope(void) +{ + ::ImGui::PopFocusScope(); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetCurrentFocusScope(void) +{ + return ::ImGui::GetCurrentFocusScope(); +} + +CIMGUI_API bool cimgui::ImGui_IsDragDropActive(void) +{ + return ::ImGui::IsDragDropActive(); +} + +CIMGUI_API bool cimgui::ImGui_BeginDragDropTargetCustom(cimgui::ImRect bb, ImGuiID id) +{ + return ::ImGui::BeginDragDropTargetCustom(ConvertToCPP_ImRect(bb), id); +} + +CIMGUI_API void cimgui::ImGui_ClearDragDrop(void) +{ + ::ImGui::ClearDragDrop(); +} + +CIMGUI_API bool cimgui::ImGui_IsDragDropPayloadBeingAccepted(void) +{ + return ::ImGui::IsDragDropPayloadBeingAccepted(); +} + +CIMGUI_API void cimgui::ImGui_RenderDragDropTargetRect(cimgui::ImRect bb, cimgui::ImRect item_clip_rect) +{ + ::ImGui::RenderDragDropTargetRect(ConvertToCPP_ImRect(bb), ConvertToCPP_ImRect(item_clip_rect)); +} + +CIMGUI_API cimgui::ImGuiTypingSelectRequest* cimgui::ImGui_GetTypingSelectRequest(void) +{ + return reinterpret_cast<::cimgui::ImGuiTypingSelectRequest*>(::ImGui::GetTypingSelectRequest()); +} + +CIMGUI_API cimgui::ImGuiTypingSelectRequest* cimgui::ImGui_GetTypingSelectRequestEx(ImGuiTypingSelectFlags flags) +{ + return reinterpret_cast<::cimgui::ImGuiTypingSelectRequest*>(::ImGui::GetTypingSelectRequest(flags)); +} + +CIMGUI_API int cimgui::ImGui_TypingSelectFindMatch(cimgui::ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx) +{ + return ::ImGui::TypingSelectFindMatch(reinterpret_cast<::ImGuiTypingSelectRequest*>(req), items_count, get_item_name_func, user_data, nav_item_idx); +} + +CIMGUI_API int cimgui::ImGui_TypingSelectFindNextSingleCharMatch(cimgui::ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx) +{ + return ::ImGui::TypingSelectFindNextSingleCharMatch(reinterpret_cast<::ImGuiTypingSelectRequest*>(req), items_count, get_item_name_func, user_data, nav_item_idx); +} + +CIMGUI_API int cimgui::ImGui_TypingSelectFindBestLeadingMatch(cimgui::ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data) +{ + return ::ImGui::TypingSelectFindBestLeadingMatch(reinterpret_cast<::ImGuiTypingSelectRequest*>(req), items_count, get_item_name_func, user_data); +} + +CIMGUI_API bool cimgui::ImGui_BeginBoxSelect(cimgui::ImRect scope_rect, cimgui::ImGuiWindow* window, ImGuiID box_select_id, ImGuiMultiSelectFlags ms_flags) +{ + return ::ImGui::BeginBoxSelect(ConvertToCPP_ImRect(scope_rect), reinterpret_cast<::ImGuiWindow*>(window), box_select_id, ms_flags); +} + +CIMGUI_API void cimgui::ImGui_EndBoxSelect(cimgui::ImRect scope_rect, ImGuiMultiSelectFlags ms_flags) +{ + ::ImGui::EndBoxSelect(ConvertToCPP_ImRect(scope_rect), ms_flags); +} + +CIMGUI_API void cimgui::ImGui_MultiSelectItemHeader(ImGuiID id, bool* p_selected, ImGuiButtonFlags* p_button_flags) +{ + ::ImGui::MultiSelectItemHeader(id, p_selected, p_button_flags); +} + +CIMGUI_API void cimgui::ImGui_MultiSelectItemFooter(ImGuiID id, bool* p_selected, bool* p_pressed) +{ + ::ImGui::MultiSelectItemFooter(id, p_selected, p_pressed); +} + +CIMGUI_API void cimgui::ImGui_MultiSelectAddSetAll(cimgui::ImGuiMultiSelectTempData* ms, bool selected) +{ + ::ImGui::MultiSelectAddSetAll(reinterpret_cast<::ImGuiMultiSelectTempData*>(ms), selected); +} + +CIMGUI_API void cimgui::ImGui_MultiSelectAddSetRange(cimgui::ImGuiMultiSelectTempData* ms, bool selected, int range_dir, ImGuiSelectionUserData first_item, ImGuiSelectionUserData last_item) +{ + ::ImGui::MultiSelectAddSetRange(reinterpret_cast<::ImGuiMultiSelectTempData*>(ms), selected, range_dir, first_item, last_item); +} + +CIMGUI_API cimgui::ImGuiBoxSelectState* cimgui::ImGui_GetBoxSelectState(ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiBoxSelectState*>(::ImGui::GetBoxSelectState(id)); +} + +CIMGUI_API cimgui::ImGuiMultiSelectState* cimgui::ImGui_GetMultiSelectState(ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiMultiSelectState*>(::ImGui::GetMultiSelectState(id)); +} + +CIMGUI_API void cimgui::ImGui_SetWindowClipRectBeforeSetChannel(cimgui::ImGuiWindow* window, cimgui::ImRect clip_rect) +{ + ::ImGui::SetWindowClipRectBeforeSetChannel(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(clip_rect)); +} + +CIMGUI_API void cimgui::ImGui_BeginColumns(const char* str_id, int count, ImGuiOldColumnFlags flags) +{ + ::ImGui::BeginColumns(str_id, count, flags); +} + +CIMGUI_API void cimgui::ImGui_EndColumns(void) +{ + ::ImGui::EndColumns(); +} + +CIMGUI_API void cimgui::ImGui_PushColumnClipRect(int column_index) +{ + ::ImGui::PushColumnClipRect(column_index); +} + +CIMGUI_API void cimgui::ImGui_PushColumnsBackground(void) +{ + ::ImGui::PushColumnsBackground(); +} + +CIMGUI_API void cimgui::ImGui_PopColumnsBackground(void) +{ + ::ImGui::PopColumnsBackground(); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetColumnsID(const char* str_id, int count) +{ + return ::ImGui::GetColumnsID(str_id, count); +} + +CIMGUI_API cimgui::ImGuiOldColumns* cimgui::ImGui_FindOrCreateColumns(cimgui::ImGuiWindow* window, ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiOldColumns*>(::ImGui::FindOrCreateColumns(reinterpret_cast<::ImGuiWindow*>(window), id)); +} + +CIMGUI_API float cimgui::ImGui_GetColumnOffsetFromNorm(const cimgui::ImGuiOldColumns* columns, float offset_norm) +{ + return ::ImGui::GetColumnOffsetFromNorm(reinterpret_cast(columns), offset_norm); +} + +CIMGUI_API float cimgui::ImGui_GetColumnNormFromOffset(const cimgui::ImGuiOldColumns* columns, float offset) +{ + return ::ImGui::GetColumnNormFromOffset(reinterpret_cast(columns), offset); +} + +CIMGUI_API void cimgui::ImGui_TableOpenContextMenu(void) +{ + ::ImGui::TableOpenContextMenu(); +} + +CIMGUI_API void cimgui::ImGui_TableOpenContextMenuEx(int column_n) +{ + ::ImGui::TableOpenContextMenu(column_n); +} + +CIMGUI_API void cimgui::ImGui_TableSetColumnWidth(int column_n, float width) +{ + ::ImGui::TableSetColumnWidth(column_n, width); +} + +CIMGUI_API void cimgui::ImGui_TableSetColumnSortDirection(int column_n, cimgui::ImGuiSortDirection sort_direction, bool append_to_sort_specs) +{ + ::ImGui::TableSetColumnSortDirection(column_n, static_cast<::ImGuiSortDirection>(sort_direction), append_to_sort_specs); +} + +CIMGUI_API int cimgui::ImGui_TableGetHoveredRow(void) +{ + return ::ImGui::TableGetHoveredRow(); +} + +CIMGUI_API float cimgui::ImGui_TableGetHeaderRowHeight(void) +{ + return ::ImGui::TableGetHeaderRowHeight(); +} + +CIMGUI_API float cimgui::ImGui_TableGetHeaderAngledMaxLabelWidth(void) +{ + return ::ImGui::TableGetHeaderAngledMaxLabelWidth(); +} + +CIMGUI_API void cimgui::ImGui_TablePushBackgroundChannel(void) +{ + ::ImGui::TablePushBackgroundChannel(); +} + +CIMGUI_API void cimgui::ImGui_TablePopBackgroundChannel(void) +{ + ::ImGui::TablePopBackgroundChannel(); +} + +CIMGUI_API void cimgui::ImGui_TablePushColumnChannel(int column_n) +{ + ::ImGui::TablePushColumnChannel(column_n); +} + +CIMGUI_API void cimgui::ImGui_TablePopColumnChannel(void) +{ + ::ImGui::TablePopColumnChannel(); +} + +CIMGUI_API void cimgui::ImGui_TableAngledHeadersRowEx(ImGuiID row_id, float angle, float max_label_width, const cimgui::ImGuiTableHeaderData* data, int data_count) +{ + ::ImGui::TableAngledHeadersRowEx(row_id, angle, max_label_width, reinterpret_cast(data), data_count); +} + +CIMGUI_API cimgui::ImGuiTable* cimgui::ImGui_GetCurrentTable(void) +{ + return reinterpret_cast<::cimgui::ImGuiTable*>(::ImGui::GetCurrentTable()); +} + +CIMGUI_API cimgui::ImGuiTable* cimgui::ImGui_TableFindByID(ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiTable*>(::ImGui::TableFindByID(id)); +} + +CIMGUI_API bool cimgui::ImGui_BeginTableWithID(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags) +{ + return ::ImGui::BeginTableEx(name, id, columns_count, flags); +} + +CIMGUI_API bool cimgui::ImGui_BeginTableWithIDEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags, cimgui::ImVec2 outer_size, float inner_width) +{ + return ::ImGui::BeginTableEx(name, id, columns_count, flags, ConvertToCPP_ImVec2(outer_size), inner_width); +} + +CIMGUI_API void cimgui::ImGui_TableBeginInitMemory(cimgui::ImGuiTable* table, int columns_count) +{ + ::ImGui::TableBeginInitMemory(reinterpret_cast<::ImGuiTable*>(table), columns_count); +} + +CIMGUI_API void cimgui::ImGui_TableBeginApplyRequests(cimgui::ImGuiTable* table) +{ + ::ImGui::TableBeginApplyRequests(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableSetupDrawChannels(cimgui::ImGuiTable* table) +{ + ::ImGui::TableSetupDrawChannels(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableUpdateLayout(cimgui::ImGuiTable* table) +{ + ::ImGui::TableUpdateLayout(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableUpdateBorders(cimgui::ImGuiTable* table) +{ + ::ImGui::TableUpdateBorders(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableUpdateColumnsWeightFromWidth(cimgui::ImGuiTable* table) +{ + ::ImGui::TableUpdateColumnsWeightFromWidth(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableDrawBorders(cimgui::ImGuiTable* table) +{ + ::ImGui::TableDrawBorders(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableDrawDefaultContextMenu(cimgui::ImGuiTable* table, ImGuiTableFlags flags_for_section_to_display) +{ + ::ImGui::TableDrawDefaultContextMenu(reinterpret_cast<::ImGuiTable*>(table), flags_for_section_to_display); +} + +CIMGUI_API bool cimgui::ImGui_TableBeginContextMenuPopup(cimgui::ImGuiTable* table) +{ + return ::ImGui::TableBeginContextMenuPopup(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableMergeDrawChannels(cimgui::ImGuiTable* table) +{ + ::ImGui::TableMergeDrawChannels(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API cimgui::ImGuiTableInstanceData* cimgui::ImGui_TableGetInstanceData(cimgui::ImGuiTable* table, int instance_no) +{ + return reinterpret_cast<::cimgui::ImGuiTableInstanceData*>(::ImGui::TableGetInstanceData(reinterpret_cast<::ImGuiTable*>(table), instance_no)); +} + +CIMGUI_API ImGuiID cimgui::ImGui_TableGetInstanceID(cimgui::ImGuiTable* table, int instance_no) +{ + return ::ImGui::TableGetInstanceID(reinterpret_cast<::ImGuiTable*>(table), instance_no); +} + +CIMGUI_API void cimgui::ImGui_TableSortSpecsSanitize(cimgui::ImGuiTable* table) +{ + ::ImGui::TableSortSpecsSanitize(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableSortSpecsBuild(cimgui::ImGuiTable* table) +{ + ::ImGui::TableSortSpecsBuild(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API cimgui::ImGuiSortDirection cimgui::ImGui_TableGetColumnNextSortDirection(cimgui::ImGuiTableColumn* column) +{ + return static_cast<::cimgui::ImGuiSortDirection>(::ImGui::TableGetColumnNextSortDirection(reinterpret_cast<::ImGuiTableColumn*>(column))); +} + +CIMGUI_API void cimgui::ImGui_TableFixColumnSortDirection(cimgui::ImGuiTable* table, cimgui::ImGuiTableColumn* column) +{ + ::ImGui::TableFixColumnSortDirection(reinterpret_cast<::ImGuiTable*>(table), reinterpret_cast<::ImGuiTableColumn*>(column)); +} + +CIMGUI_API float cimgui::ImGui_TableGetColumnWidthAuto(cimgui::ImGuiTable* table, cimgui::ImGuiTableColumn* column) +{ + return ::ImGui::TableGetColumnWidthAuto(reinterpret_cast<::ImGuiTable*>(table), reinterpret_cast<::ImGuiTableColumn*>(column)); +} + +CIMGUI_API void cimgui::ImGui_TableBeginRow(cimgui::ImGuiTable* table) +{ + ::ImGui::TableBeginRow(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableEndRow(cimgui::ImGuiTable* table) +{ + ::ImGui::TableEndRow(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableBeginCell(cimgui::ImGuiTable* table, int column_n) +{ + ::ImGui::TableBeginCell(reinterpret_cast<::ImGuiTable*>(table), column_n); +} + +CIMGUI_API void cimgui::ImGui_TableEndCell(cimgui::ImGuiTable* table) +{ + ::ImGui::TableEndCell(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGui_TableGetCellBgRect(const cimgui::ImGuiTable* table, int column_n) +{ + return ConvertFromCPP_ImRect(::ImGui::TableGetCellBgRect(reinterpret_cast(table), column_n)); +} + +CIMGUI_API const char* cimgui::ImGui_TableGetColumnNameImGuiTablePtr(const cimgui::ImGuiTable* table, int column_n) +{ + return ::ImGui::TableGetColumnName(reinterpret_cast(table), column_n); +} + +CIMGUI_API ImGuiID cimgui::ImGui_TableGetColumnResizeID(cimgui::ImGuiTable* table, int column_n) +{ + return ::ImGui::TableGetColumnResizeID(reinterpret_cast<::ImGuiTable*>(table), column_n); +} + +CIMGUI_API ImGuiID cimgui::ImGui_TableGetColumnResizeIDEx(cimgui::ImGuiTable* table, int column_n, int instance_no) +{ + return ::ImGui::TableGetColumnResizeID(reinterpret_cast<::ImGuiTable*>(table), column_n, instance_no); +} + +CIMGUI_API float cimgui::ImGui_TableCalcMaxColumnWidth(const cimgui::ImGuiTable* table, int column_n) +{ + return ::ImGui::TableCalcMaxColumnWidth(reinterpret_cast(table), column_n); +} + +CIMGUI_API void cimgui::ImGui_TableSetColumnWidthAutoSingle(cimgui::ImGuiTable* table, int column_n) +{ + ::ImGui::TableSetColumnWidthAutoSingle(reinterpret_cast<::ImGuiTable*>(table), column_n); +} + +CIMGUI_API void cimgui::ImGui_TableSetColumnWidthAutoAll(cimgui::ImGuiTable* table) +{ + ::ImGui::TableSetColumnWidthAutoAll(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableRemove(cimgui::ImGuiTable* table) +{ + ::ImGui::TableRemove(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableGcCompactTransientBuffers(cimgui::ImGuiTable* table) +{ + ::ImGui::TableGcCompactTransientBuffers(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableGcCompactTransientBuffersImGuiTableTempDataPtr(cimgui::ImGuiTableTempData* table) +{ + ::ImGui::TableGcCompactTransientBuffers(reinterpret_cast<::ImGuiTableTempData*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableGcCompactSettings(void) +{ + ::ImGui::TableGcCompactSettings(); +} + +CIMGUI_API void cimgui::ImGui_TableLoadSettings(cimgui::ImGuiTable* table) +{ + ::ImGui::TableLoadSettings(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableSaveSettings(cimgui::ImGuiTable* table) +{ + ::ImGui::TableSaveSettings(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_TableResetSettings(cimgui::ImGuiTable* table) +{ + ::ImGui::TableResetSettings(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API cimgui::ImGuiTableSettings* cimgui::ImGui_TableGetBoundSettings(cimgui::ImGuiTable* table) +{ + return reinterpret_cast<::cimgui::ImGuiTableSettings*>(::ImGui::TableGetBoundSettings(reinterpret_cast<::ImGuiTable*>(table))); +} + +CIMGUI_API void cimgui::ImGui_TableSettingsAddSettingsHandler(void) +{ + ::ImGui::TableSettingsAddSettingsHandler(); +} + +CIMGUI_API cimgui::ImGuiTableSettings* cimgui::ImGui_TableSettingsCreate(ImGuiID id, int columns_count) +{ + return reinterpret_cast<::cimgui::ImGuiTableSettings*>(::ImGui::TableSettingsCreate(id, columns_count)); +} + +CIMGUI_API cimgui::ImGuiTableSettings* cimgui::ImGui_TableSettingsFindByID(ImGuiID id) +{ + return reinterpret_cast<::cimgui::ImGuiTableSettings*>(::ImGui::TableSettingsFindByID(id)); +} + +CIMGUI_API cimgui::ImGuiTabBar* cimgui::ImGui_GetCurrentTabBar(void) +{ + return reinterpret_cast<::cimgui::ImGuiTabBar*>(::ImGui::GetCurrentTabBar()); +} + +CIMGUI_API bool cimgui::ImGui_BeginTabBarEx(cimgui::ImGuiTabBar* tab_bar, cimgui::ImRect bb, ImGuiTabBarFlags flags) +{ + return ::ImGui::BeginTabBarEx(reinterpret_cast<::ImGuiTabBar*>(tab_bar), ConvertToCPP_ImRect(bb), flags); +} + +CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarFindTabByID(cimgui::ImGuiTabBar* tab_bar, ImGuiID tab_id) +{ + return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarFindTabByID(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_id)); +} + +CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarFindTabByOrder(cimgui::ImGuiTabBar* tab_bar, int order) +{ + return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarFindTabByOrder(reinterpret_cast<::ImGuiTabBar*>(tab_bar), order)); +} + +CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarFindMostRecentlySelectedTabForActiveWindow(cimgui::ImGuiTabBar* tab_bar) +{ + return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(reinterpret_cast<::ImGuiTabBar*>(tab_bar))); +} + +CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarGetCurrentTab(cimgui::ImGuiTabBar* tab_bar) +{ + return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarGetCurrentTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar))); +} + +CIMGUI_API int cimgui::ImGui_TabBarGetTabOrder(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab) +{ + return ::ImGui::TabBarGetTabOrder(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab)); +} + +CIMGUI_API const char* cimgui::ImGui_TabBarGetTabName(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab) +{ + return ::ImGui::TabBarGetTabName(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab)); +} + +CIMGUI_API void cimgui::ImGui_TabBarAddTab(cimgui::ImGuiTabBar* tab_bar, ImGuiTabItemFlags tab_flags, cimgui::ImGuiWindow* window) +{ + ::ImGui::TabBarAddTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_flags, reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_TabBarRemoveTab(cimgui::ImGuiTabBar* tab_bar, ImGuiID tab_id) +{ + ::ImGui::TabBarRemoveTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_id); +} + +CIMGUI_API void cimgui::ImGui_TabBarCloseTab(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab) +{ + ::ImGui::TabBarCloseTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab)); +} + +CIMGUI_API void cimgui::ImGui_TabBarQueueFocus(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab) +{ + ::ImGui::TabBarQueueFocus(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab)); +} + +CIMGUI_API void cimgui::ImGui_TabBarQueueFocusStr(cimgui::ImGuiTabBar* tab_bar, const char* tab_name) +{ + ::ImGui::TabBarQueueFocus(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_name); +} + +CIMGUI_API void cimgui::ImGui_TabBarQueueReorder(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab, int offset) +{ + ::ImGui::TabBarQueueReorder(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab), offset); +} + +CIMGUI_API void cimgui::ImGui_TabBarQueueReorderFromMousePos(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab, cimgui::ImVec2 mouse_pos) +{ + ::ImGui::TabBarQueueReorderFromMousePos(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab), ConvertToCPP_ImVec2(mouse_pos)); +} + +CIMGUI_API bool cimgui::ImGui_TabBarProcessReorder(cimgui::ImGuiTabBar* tab_bar) +{ + return ::ImGui::TabBarProcessReorder(reinterpret_cast<::ImGuiTabBar*>(tab_bar)); +} + +CIMGUI_API bool cimgui::ImGui_TabItemEx(cimgui::ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags, cimgui::ImGuiWindow* docked_window) +{ + return ::ImGui::TabItemEx(reinterpret_cast<::ImGuiTabBar*>(tab_bar), label, p_open, flags, reinterpret_cast<::ImGuiWindow*>(docked_window)); +} + +CIMGUI_API void cimgui::ImGui_TabItemSpacing(const char* str_id, ImGuiTabItemFlags flags, float width) +{ + ::ImGui::TabItemSpacing(str_id, flags, width); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_TabItemCalcSizeStr(const char* label, bool has_close_button_or_unsaved_marker) +{ + return ConvertFromCPP_ImVec2(::ImGui::TabItemCalcSize(label, has_close_button_or_unsaved_marker)); +} + +CIMGUI_API cimgui::ImVec2 cimgui::ImGui_TabItemCalcSize(cimgui::ImGuiWindow* window) +{ + return ConvertFromCPP_ImVec2(::ImGui::TabItemCalcSize(reinterpret_cast<::ImGuiWindow*>(window))); +} + +CIMGUI_API void cimgui::ImGui_TabItemBackground(cimgui::ImDrawList* draw_list, cimgui::ImRect bb, ImGuiTabItemFlags flags, ImU32 col) +{ + ::ImGui::TabItemBackground(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(bb), flags, col); +} + +CIMGUI_API void cimgui::ImGui_TabItemLabelAndCloseButton(cimgui::ImDrawList* draw_list, cimgui::ImRect bb, ImGuiTabItemFlags flags, cimgui::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) +{ + ::ImGui::TabItemLabelAndCloseButton(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(bb), flags, ConvertToCPP_ImVec2(frame_padding), label, tab_id, close_button_id, is_contents_visible, out_just_closed, out_text_clipped); +} + +CIMGUI_API void cimgui::ImGui_RenderText(cimgui::ImVec2 pos, const char* text) +{ + ::ImGui::RenderText(ConvertToCPP_ImVec2(pos), text); +} + +CIMGUI_API void cimgui::ImGui_RenderTextEx(cimgui::ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash) +{ + ::ImGui::RenderText(ConvertToCPP_ImVec2(pos), text, text_end, hide_text_after_hash); +} + +CIMGUI_API void cimgui::ImGui_RenderTextWrapped(cimgui::ImVec2 pos, const char* text, const char* text_end, float wrap_width) +{ + ::ImGui::RenderTextWrapped(ConvertToCPP_ImVec2(pos), text, text_end, wrap_width); +} + +CIMGUI_API void cimgui::ImGui_RenderTextClipped(cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known) +{ + ::ImGui::RenderTextClipped(ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), text, text_end, reinterpret_cast(text_size_if_known)); +} + +CIMGUI_API void cimgui::ImGui_RenderTextClippedEx(cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known, cimgui::ImVec2 align, const cimgui::ImRect* clip_rect) +{ + ::ImGui::RenderTextClipped(ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), text, text_end, reinterpret_cast(text_size_if_known), ConvertToCPP_ImVec2(align), reinterpret_cast(clip_rect)); +} + +CIMGUI_API void cimgui::ImGui_RenderTextClippedWithDrawList(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known) +{ + ::ImGui::RenderTextClippedEx(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), text, text_end, reinterpret_cast(text_size_if_known)); +} + +CIMGUI_API void cimgui::ImGui_RenderTextClippedWithDrawListEx(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known, cimgui::ImVec2 align, const cimgui::ImRect* clip_rect) +{ + ::ImGui::RenderTextClippedEx(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), text, text_end, reinterpret_cast(text_size_if_known), ConvertToCPP_ImVec2(align), reinterpret_cast(clip_rect)); +} + +CIMGUI_API void cimgui::ImGui_RenderTextEllipsis(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, float ellipsis_max_x, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known) +{ + ::ImGui::RenderTextEllipsis(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), ellipsis_max_x, text, text_end, reinterpret_cast(text_size_if_known)); +} + +CIMGUI_API void cimgui::ImGui_RenderFrame(cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 fill_col) +{ + ::ImGui::RenderFrame(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), fill_col); +} + +CIMGUI_API void cimgui::ImGui_RenderFrameEx(cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 fill_col, bool borders, float rounding) +{ + ::ImGui::RenderFrame(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), fill_col, borders, rounding); +} + +CIMGUI_API void cimgui::ImGui_RenderFrameBorder(cimgui::ImVec2 p_min, cimgui::ImVec2 p_max) +{ + ::ImGui::RenderFrameBorder(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max)); +} + +CIMGUI_API void cimgui::ImGui_RenderFrameBorderEx(cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, float rounding) +{ + ::ImGui::RenderFrameBorder(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), rounding); +} + +CIMGUI_API void cimgui::ImGui_RenderColorRectWithAlphaCheckerboard(cimgui::ImDrawList* draw_list, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 fill_col, float grid_step, cimgui::ImVec2 grid_off) +{ + ::ImGui::RenderColorRectWithAlphaCheckerboard(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), fill_col, grid_step, ConvertToCPP_ImVec2(grid_off)); +} + +CIMGUI_API void cimgui::ImGui_RenderColorRectWithAlphaCheckerboardEx(cimgui::ImDrawList* draw_list, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 fill_col, float grid_step, cimgui::ImVec2 grid_off, float rounding, ImDrawFlags flags) +{ + ::ImGui::RenderColorRectWithAlphaCheckerboard(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), fill_col, grid_step, ConvertToCPP_ImVec2(grid_off), rounding, flags); +} + +CIMGUI_API void cimgui::ImGui_RenderNavCursor(cimgui::ImRect bb, ImGuiID id) +{ + ::ImGui::RenderNavCursor(ConvertToCPP_ImRect(bb), id); +} + +CIMGUI_API void cimgui::ImGui_RenderNavCursorEx(cimgui::ImRect bb, ImGuiID id, ImGuiNavRenderCursorFlags flags) +{ + ::ImGui::RenderNavCursor(ConvertToCPP_ImRect(bb), id, flags); +} + +#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS + +CIMGUI_API void cimgui::ImGui_RenderNavHighlight(cimgui::ImRect bb, ImGuiID id) +{ + ::ImGui::RenderNavHighlight(ConvertToCPP_ImRect(bb), id); +} + +CIMGUI_API void cimgui::ImGui_RenderNavHighlightEx(cimgui::ImRect bb, ImGuiID id, ImGuiNavRenderCursorFlags flags) +{ + ::ImGui::RenderNavHighlight(ConvertToCPP_ImRect(bb), id, flags); +} + +#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS + +CIMGUI_API const char* cimgui::ImGui_FindRenderedTextEnd(const char* text) +{ + return ::ImGui::FindRenderedTextEnd(text); +} + +CIMGUI_API const char* cimgui::ImGui_FindRenderedTextEndEx(const char* text, const char* text_end) +{ + return ::ImGui::FindRenderedTextEnd(text, text_end); +} + +CIMGUI_API void cimgui::ImGui_RenderMouseCursor(cimgui::ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow) +{ + ::ImGui::RenderMouseCursor(ConvertToCPP_ImVec2(pos), scale, mouse_cursor, col_fill, col_border, col_shadow); +} + +CIMGUI_API void cimgui::ImGui_RenderArrow(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, ImU32 col, cimgui::ImGuiDir dir) +{ + ::ImGui::RenderArrow(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), col, static_cast<::ImGuiDir>(dir)); +} + +CIMGUI_API void cimgui::ImGui_RenderArrowEx(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, ImU32 col, cimgui::ImGuiDir dir, float scale) +{ + ::ImGui::RenderArrow(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), col, static_cast<::ImGuiDir>(dir), scale); +} + +CIMGUI_API void cimgui::ImGui_RenderBullet(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, ImU32 col) +{ + ::ImGui::RenderBullet(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), col); +} + +CIMGUI_API void cimgui::ImGui_RenderCheckMark(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, ImU32 col, float sz) +{ + ::ImGui::RenderCheckMark(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), col, sz); +} + +CIMGUI_API void cimgui::ImGui_RenderArrowPointingAt(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, cimgui::ImVec2 half_sz, cimgui::ImGuiDir direction, ImU32 col) +{ + ::ImGui::RenderArrowPointingAt(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), ConvertToCPP_ImVec2(half_sz), static_cast<::ImGuiDir>(direction), col); +} + +CIMGUI_API void cimgui::ImGui_RenderArrowDockMenu(cimgui::ImDrawList* draw_list, cimgui::ImVec2 p_min, float sz, ImU32 col) +{ + ::ImGui::RenderArrowDockMenu(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(p_min), sz, col); +} + +CIMGUI_API void cimgui::ImGui_RenderRectFilledRangeH(cimgui::ImDrawList* draw_list, cimgui::ImRect rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding) +{ + ::ImGui::RenderRectFilledRangeH(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(rect), col, x_start_norm, x_end_norm, rounding); +} + +CIMGUI_API void cimgui::ImGui_RenderRectFilledWithHole(cimgui::ImDrawList* draw_list, cimgui::ImRect outer, cimgui::ImRect inner, ImU32 col, float rounding) +{ + ::ImGui::RenderRectFilledWithHole(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(outer), ConvertToCPP_ImRect(inner), col, rounding); +} + +CIMGUI_API ImDrawFlags cimgui::ImGui_CalcRoundingFlagsForRectInRect(cimgui::ImRect r_in, cimgui::ImRect r_outer, float threshold) +{ + return ::ImGui::CalcRoundingFlagsForRectInRect(ConvertToCPP_ImRect(r_in), ConvertToCPP_ImRect(r_outer), threshold); +} + +CIMGUI_API void cimgui::ImGui_TextEx(const char* text) +{ + ::ImGui::TextEx(text); +} + +CIMGUI_API void cimgui::ImGui_TextExEx(const char* text, const char* text_end, ImGuiTextFlags flags) +{ + ::ImGui::TextEx(text, text_end, flags); +} + +CIMGUI_API void cimgui::ImGui_TextAligned(float align_x, float size_x, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + ::ImGui::TextAlignedV(align_x, size_x, fmt, args); + va_end(args); +} + +CIMGUI_API void cimgui::ImGui_TextAlignedV(float align_x, float size_x, const char* fmt, va_list args) +{ + ::ImGui::TextAlignedV(align_x, size_x, fmt, args); +} + +CIMGUI_API bool cimgui::ImGui_ButtonWithFlags(const char* label) +{ + return ::ImGui::ButtonEx(label); +} + +CIMGUI_API bool cimgui::ImGui_ButtonWithFlagsEx(const char* label, cimgui::ImVec2 size_arg, ImGuiButtonFlags flags) +{ + return ::ImGui::ButtonEx(label, ConvertToCPP_ImVec2(size_arg), flags); +} + +CIMGUI_API bool cimgui::ImGui_ArrowButtonEx(const char* str_id, cimgui::ImGuiDir dir, cimgui::ImVec2 size_arg, ImGuiButtonFlags flags) +{ + return ::ImGui::ArrowButtonEx(str_id, static_cast<::ImGuiDir>(dir), ConvertToCPP_ImVec2(size_arg), flags); +} + +CIMGUI_API bool cimgui::ImGui_ImageButtonWithFlags(ImGuiID id, cimgui::ImTextureRef tex_ref, cimgui::ImVec2 image_size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, cimgui::ImVec4 bg_col, cimgui::ImVec4 tint_col, ImGuiButtonFlags flags) +{ + return ::ImGui::ImageButtonEx(id, ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(image_size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec4(bg_col), ConvertToCPP_ImVec4(tint_col), flags); +} + +CIMGUI_API void cimgui::ImGui_SeparatorEx(ImGuiSeparatorFlags flags) +{ + ::ImGui::SeparatorEx(flags); +} + +CIMGUI_API void cimgui::ImGui_SeparatorExEx(ImGuiSeparatorFlags flags, float thickness) +{ + ::ImGui::SeparatorEx(flags, thickness); +} + +CIMGUI_API void cimgui::ImGui_SeparatorTextEx(ImGuiID id, const char* label, const char* label_end, float extra_width) +{ + ::ImGui::SeparatorTextEx(id, label, label_end, extra_width); +} + +CIMGUI_API bool cimgui::ImGui_CheckboxFlagsImS64Ptr(const char* label, ImS64* flags, ImS64 flags_value) +{ + return ::ImGui::CheckboxFlags(label, flags, flags_value); +} + +CIMGUI_API bool cimgui::ImGui_CheckboxFlagsImU64Ptr(const char* label, ImU64* flags, ImU64 flags_value) +{ + return ::ImGui::CheckboxFlags(label, flags, flags_value); +} + +CIMGUI_API bool cimgui::ImGui_CloseButton(ImGuiID id, cimgui::ImVec2 pos) +{ + return ::ImGui::CloseButton(id, ConvertToCPP_ImVec2(pos)); +} + +CIMGUI_API bool cimgui::ImGui_CollapseButton(ImGuiID id, cimgui::ImVec2 pos, cimgui::ImGuiDockNode* dock_node) +{ + return ::ImGui::CollapseButton(id, ConvertToCPP_ImVec2(pos), reinterpret_cast<::ImGuiDockNode*>(dock_node)); +} + +CIMGUI_API void cimgui::ImGui_Scrollbar(cimgui::ImGuiAxis axis) +{ + ::ImGui::Scrollbar(static_cast<::ImGuiAxis>(axis)); +} + +CIMGUI_API bool cimgui::ImGui_ScrollbarEx(cimgui::ImRect bb, ImGuiID id, cimgui::ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v) +{ + return ::ImGui::ScrollbarEx(ConvertToCPP_ImRect(bb), id, static_cast<::ImGuiAxis>(axis), p_scroll_v, avail_v, contents_v); +} + +CIMGUI_API bool cimgui::ImGui_ScrollbarExEx(cimgui::ImRect bb, ImGuiID id, cimgui::ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v, ImDrawFlags draw_rounding_flags) +{ + return ::ImGui::ScrollbarEx(ConvertToCPP_ImRect(bb), id, static_cast<::ImGuiAxis>(axis), p_scroll_v, avail_v, contents_v, draw_rounding_flags); +} + +CIMGUI_API cimgui::ImRect cimgui::ImGui_GetWindowScrollbarRect(cimgui::ImGuiWindow* window, cimgui::ImGuiAxis axis) +{ + return ConvertFromCPP_ImRect(::ImGui::GetWindowScrollbarRect(reinterpret_cast<::ImGuiWindow*>(window), static_cast<::ImGuiAxis>(axis))); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetWindowScrollbarID(cimgui::ImGuiWindow* window, cimgui::ImGuiAxis axis) +{ + return ::ImGui::GetWindowScrollbarID(reinterpret_cast<::ImGuiWindow*>(window), static_cast<::ImGuiAxis>(axis)); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetWindowResizeCornerID(cimgui::ImGuiWindow* window, int n) +{ + return ::ImGui::GetWindowResizeCornerID(reinterpret_cast<::ImGuiWindow*>(window), n); +} + +CIMGUI_API ImGuiID cimgui::ImGui_GetWindowResizeBorderID(cimgui::ImGuiWindow* window, cimgui::ImGuiDir dir) +{ + return ::ImGui::GetWindowResizeBorderID(reinterpret_cast<::ImGuiWindow*>(window), static_cast<::ImGuiDir>(dir)); +} + +CIMGUI_API bool cimgui::ImGui_ButtonBehavior(cimgui::ImRect bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags) +{ + return ::ImGui::ButtonBehavior(ConvertToCPP_ImRect(bb), id, out_hovered, out_held, flags); +} + +CIMGUI_API bool cimgui::ImGui_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) +{ + return ::ImGui::DragBehavior(id, data_type, p_v, v_speed, p_min, p_max, format, flags); +} + +CIMGUI_API bool cimgui::ImGui_SliderBehavior(cimgui::ImRect bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, cimgui::ImRect* out_grab_bb) +{ + return ::ImGui::SliderBehavior(ConvertToCPP_ImRect(bb), id, data_type, p_v, p_min, p_max, format, flags, reinterpret_cast<::ImRect*>(out_grab_bb)); +} + +CIMGUI_API bool cimgui::ImGui_SplitterBehavior(cimgui::ImRect bb, ImGuiID id, cimgui::ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2) +{ + return ::ImGui::SplitterBehavior(ConvertToCPP_ImRect(bb), id, static_cast<::ImGuiAxis>(axis), size1, size2, min_size1, min_size2); +} + +CIMGUI_API bool cimgui::ImGui_SplitterBehaviorEx(cimgui::ImRect bb, ImGuiID id, cimgui::ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend, float hover_visibility_delay, ImU32 bg_col) +{ + return ::ImGui::SplitterBehavior(ConvertToCPP_ImRect(bb), id, static_cast<::ImGuiAxis>(axis), size1, size2, min_size1, min_size2, hover_extend, hover_visibility_delay, bg_col); +} + +CIMGUI_API bool cimgui::ImGui_TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label) +{ + return ::ImGui::TreeNodeBehavior(id, flags, label); +} + +CIMGUI_API bool cimgui::ImGui_TreeNodeBehaviorEx(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end) +{ + return ::ImGui::TreeNodeBehavior(id, flags, label, label_end); +} + +CIMGUI_API void cimgui::ImGui_TreeNodeDrawLineToChildNode(cimgui::ImVec2 target_pos) +{ + ::ImGui::TreeNodeDrawLineToChildNode(ConvertToCPP_ImVec2(target_pos)); +} + +CIMGUI_API void cimgui::ImGui_TreeNodeDrawLineToTreePop(const cimgui::ImGuiTreeNodeStackData* data) +{ + ::ImGui::TreeNodeDrawLineToTreePop(reinterpret_cast(data)); +} + +CIMGUI_API void cimgui::ImGui_TreePushOverrideID(ImGuiID id) +{ + ::ImGui::TreePushOverrideID(id); +} + +CIMGUI_API bool cimgui::ImGui_TreeNodeGetOpen(ImGuiID storage_id) +{ + return ::ImGui::TreeNodeGetOpen(storage_id); +} + +CIMGUI_API void cimgui::ImGui_TreeNodeSetOpen(ImGuiID storage_id, bool open) +{ + ::ImGui::TreeNodeSetOpen(storage_id, open); +} + +CIMGUI_API bool cimgui::ImGui_TreeNodeUpdateNextOpen(ImGuiID storage_id, ImGuiTreeNodeFlags flags) +{ + return ::ImGui::TreeNodeUpdateNextOpen(storage_id, flags); +} + +CIMGUI_API const cimgui::ImGuiDataTypeInfo* cimgui::ImGui_DataTypeGetInfo(ImGuiDataType data_type) +{ + return reinterpret_cast(::ImGui::DataTypeGetInfo(data_type)); +} + +CIMGUI_API int cimgui::ImGui_DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* p_data, const char* format) +{ + return ::ImGui::DataTypeFormatString(buf, buf_size, data_type, p_data, format); +} + +CIMGUI_API void cimgui::ImGui_DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, const void* arg_1, const void* arg_2) +{ + ::ImGui::DataTypeApplyOp(data_type, op, output, arg_1, arg_2); +} + +CIMGUI_API bool cimgui::ImGui_DataTypeApplyFromText(const char* buf, ImGuiDataType data_type, void* p_data, const char* format) +{ + return ::ImGui::DataTypeApplyFromText(buf, data_type, p_data, format); +} + +CIMGUI_API bool cimgui::ImGui_DataTypeApplyFromTextEx(const char* buf, ImGuiDataType data_type, void* p_data, const char* format, void* p_data_when_empty) +{ + return ::ImGui::DataTypeApplyFromText(buf, data_type, p_data, format, p_data_when_empty); +} + +CIMGUI_API int cimgui::ImGui_DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2) +{ + return ::ImGui::DataTypeCompare(data_type, arg_1, arg_2); +} + +CIMGUI_API bool cimgui::ImGui_DataTypeClamp(ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max) +{ + return ::ImGui::DataTypeClamp(data_type, p_data, p_min, p_max); +} + +CIMGUI_API bool cimgui::ImGui_DataTypeIsZero(ImGuiDataType data_type, const void* p_data) +{ + return ::ImGui::DataTypeIsZero(data_type, p_data); +} + +CIMGUI_API bool cimgui::ImGui_InputTextWithHintAndSize(const char* label, const char* hint, char* buf, int buf_size, cimgui::ImVec2 size_arg, ImGuiInputTextFlags flags) +{ + return ::ImGui::InputTextEx(label, hint, buf, buf_size, ConvertToCPP_ImVec2(size_arg), flags); +} + +CIMGUI_API bool cimgui::ImGui_InputTextWithHintAndSizeEx(const char* label, const char* hint, char* buf, int buf_size, cimgui::ImVec2 size_arg, ImGuiInputTextFlags flags, cimgui::ImGuiInputTextCallback callback, void* user_data) +{ + return ::ImGui::InputTextEx(label, hint, buf, buf_size, ConvertToCPP_ImVec2(size_arg), flags, reinterpret_cast<::ImGuiInputTextCallback>(callback), user_data); +} + +CIMGUI_API void cimgui::ImGui_InputTextDeactivateHook(ImGuiID id) +{ + ::ImGui::InputTextDeactivateHook(id); +} + +CIMGUI_API bool cimgui::ImGui_TempInputText(cimgui::ImRect bb, ImGuiID id, const char* label, char* buf, int buf_size, ImGuiInputTextFlags flags) +{ + return ::ImGui::TempInputText(ConvertToCPP_ImRect(bb), id, label, buf, buf_size, flags); +} + +CIMGUI_API bool cimgui::ImGui_TempInputScalar(cimgui::ImRect bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format) +{ + return ::ImGui::TempInputScalar(ConvertToCPP_ImRect(bb), id, label, data_type, p_data, format); +} + +CIMGUI_API bool cimgui::ImGui_TempInputScalarEx(cimgui::ImRect bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min, const void* p_clamp_max) +{ + return ::ImGui::TempInputScalar(ConvertToCPP_ImRect(bb), id, label, data_type, p_data, format, p_clamp_min, p_clamp_max); +} + +CIMGUI_API bool cimgui::ImGui_TempInputIsActive(ImGuiID id) +{ + return ::ImGui::TempInputIsActive(id); +} + +CIMGUI_API void cimgui::ImGui_SetNextItemRefVal(ImGuiDataType data_type, void* p_data) +{ + ::ImGui::SetNextItemRefVal(data_type, p_data); +} + +CIMGUI_API bool cimgui::ImGui_IsItemActiveAsInputText(void) +{ + return ::ImGui::IsItemActiveAsInputText(); +} + +CIMGUI_API void cimgui::ImGui_ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags) +{ + ::ImGui::ColorTooltip(text, col, flags); +} + +CIMGUI_API void cimgui::ImGui_ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags) +{ + ::ImGui::ColorEditOptionsPopup(col, flags); +} + +CIMGUI_API void cimgui::ImGui_ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags) +{ + ::ImGui::ColorPickerOptionsPopup(ref_col, flags); +} + +CIMGUI_API int cimgui::ImGui_PlotEx(cimgui::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, cimgui::ImVec2 size_arg) +{ + return ::ImGui::PlotEx(static_cast<::ImGuiPlotType>(plot_type), label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, ConvertToCPP_ImVec2(size_arg)); +} + +CIMGUI_API void cimgui::ImGui_ShadeVertsLinearColorGradientKeepAlpha(cimgui::ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, cimgui::ImVec2 gradient_p0, cimgui::ImVec2 gradient_p1, ImU32 col0, ImU32 col1) +{ + ::ImGui::ShadeVertsLinearColorGradientKeepAlpha(reinterpret_cast<::ImDrawList*>(draw_list), vert_start_idx, vert_end_idx, ConvertToCPP_ImVec2(gradient_p0), ConvertToCPP_ImVec2(gradient_p1), col0, col1); +} + +CIMGUI_API void cimgui::ImGui_ShadeVertsLinearUV(cimgui::ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 uv_a, cimgui::ImVec2 uv_b, bool clamp) +{ + ::ImGui::ShadeVertsLinearUV(reinterpret_cast<::ImDrawList*>(draw_list), vert_start_idx, vert_end_idx, ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(uv_a), ConvertToCPP_ImVec2(uv_b), clamp); +} + +CIMGUI_API void cimgui::ImGui_ShadeVertsTransformPos(cimgui::ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, cimgui::ImVec2 pivot_in, float cos_a, float sin_a, cimgui::ImVec2 pivot_out) +{ + ::ImGui::ShadeVertsTransformPos(reinterpret_cast<::ImDrawList*>(draw_list), vert_start_idx, vert_end_idx, ConvertToCPP_ImVec2(pivot_in), cos_a, sin_a, ConvertToCPP_ImVec2(pivot_out)); +} + +CIMGUI_API void cimgui::ImGui_GcCompactTransientMiscBuffers(void) +{ + ::ImGui::GcCompactTransientMiscBuffers(); +} + +CIMGUI_API void cimgui::ImGui_GcCompactTransientWindowBuffers(cimgui::ImGuiWindow* window) +{ + ::ImGui::GcCompactTransientWindowBuffers(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API void cimgui::ImGui_GcAwakeTransientWindowBuffers(cimgui::ImGuiWindow* window) +{ + ::ImGui::GcAwakeTransientWindowBuffers(reinterpret_cast<::ImGuiWindow*>(window)); +} + +CIMGUI_API bool cimgui::ImGui_ErrorLog(const char* msg) +{ + return ::ImGui::ErrorLog(msg); +} + +CIMGUI_API void cimgui::ImGui_ErrorRecoveryStoreState(cimgui::ImGuiErrorRecoveryState* state_out) +{ + ::ImGui::ErrorRecoveryStoreState(reinterpret_cast<::ImGuiErrorRecoveryState*>(state_out)); +} + +CIMGUI_API void cimgui::ImGui_ErrorRecoveryTryToRecoverState(const cimgui::ImGuiErrorRecoveryState* state_in) +{ + ::ImGui::ErrorRecoveryTryToRecoverState(reinterpret_cast(state_in)); +} + +CIMGUI_API void cimgui::ImGui_ErrorRecoveryTryToRecoverWindowState(const cimgui::ImGuiErrorRecoveryState* state_in) +{ + ::ImGui::ErrorRecoveryTryToRecoverWindowState(reinterpret_cast(state_in)); +} + +CIMGUI_API void cimgui::ImGui_ErrorCheckUsingSetCursorPosToExtendParentBoundaries(void) +{ + ::ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries(); +} + +CIMGUI_API void cimgui::ImGui_ErrorCheckEndFrameFinalizeErrorTooltip(void) +{ + ::ImGui::ErrorCheckEndFrameFinalizeErrorTooltip(); +} + +CIMGUI_API bool cimgui::ImGui_BeginErrorTooltip(void) +{ + return ::ImGui::BeginErrorTooltip(); +} + +CIMGUI_API void cimgui::ImGui_EndErrorTooltip(void) +{ + ::ImGui::EndErrorTooltip(); +} + +CIMGUI_API void cimgui::ImGui_DebugAllocHook(cimgui::ImGuiDebugAllocInfo* info, int frame_count, void* ptr, size_t size) +{ + ::ImGui::DebugAllocHook(reinterpret_cast<::ImGuiDebugAllocInfo*>(info), frame_count, ptr, size); +} + +CIMGUI_API void cimgui::ImGui_DebugDrawCursorPos(void) +{ + ::ImGui::DebugDrawCursorPos(); +} + +CIMGUI_API void cimgui::ImGui_DebugDrawCursorPosEx(ImU32 col) +{ + ::ImGui::DebugDrawCursorPos(col); +} + +CIMGUI_API void cimgui::ImGui_DebugDrawLineExtents(void) +{ + ::ImGui::DebugDrawLineExtents(); +} + +CIMGUI_API void cimgui::ImGui_DebugDrawLineExtentsEx(ImU32 col) +{ + ::ImGui::DebugDrawLineExtents(col); +} + +CIMGUI_API void cimgui::ImGui_DebugDrawItemRect(void) +{ + ::ImGui::DebugDrawItemRect(); +} + +CIMGUI_API void cimgui::ImGui_DebugDrawItemRectEx(ImU32 col) +{ + ::ImGui::DebugDrawItemRect(col); +} + +CIMGUI_API void cimgui::ImGui_DebugTextUnformattedWithLocateItem(const char* line_begin, const char* line_end) +{ + ::ImGui::DebugTextUnformattedWithLocateItem(line_begin, line_end); +} + +CIMGUI_API void cimgui::ImGui_DebugLocateItem(ImGuiID target_id) +{ + ::ImGui::DebugLocateItem(target_id); +} + +CIMGUI_API void cimgui::ImGui_DebugLocateItemOnHover(ImGuiID target_id) +{ + ::ImGui::DebugLocateItemOnHover(target_id); +} + +CIMGUI_API void cimgui::ImGui_DebugLocateItemResolveWithLastItem(void) +{ + ::ImGui::DebugLocateItemResolveWithLastItem(); +} + +CIMGUI_API void cimgui::ImGui_DebugBreakClearData(void) +{ + ::ImGui::DebugBreakClearData(); +} + +CIMGUI_API bool cimgui::ImGui_DebugBreakButton(const char* label, const char* description_of_location) +{ + return ::ImGui::DebugBreakButton(label, description_of_location); +} + +CIMGUI_API void cimgui::ImGui_DebugBreakButtonTooltip(bool keyboard_only, const char* description_of_location) +{ + ::ImGui::DebugBreakButtonTooltip(keyboard_only, description_of_location); +} + +CIMGUI_API void cimgui::ImGui_ShowFontAtlas(cimgui::ImFontAtlas* atlas) +{ + ::ImGui::ShowFontAtlas(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::ImGui_DebugHookIdInfo(ImGuiID id, ImGuiDataType data_type, const void* data_id, const void* data_id_end) +{ + ::ImGui::DebugHookIdInfo(id, data_type, data_id, data_id_end); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeColumns(cimgui::ImGuiOldColumns* columns) +{ + ::ImGui::DebugNodeColumns(reinterpret_cast<::ImGuiOldColumns*>(columns)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeDockNode(cimgui::ImGuiDockNode* node, const char* label) +{ + ::ImGui::DebugNodeDockNode(reinterpret_cast<::ImGuiDockNode*>(node), label); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeDrawList(cimgui::ImGuiWindow* window, cimgui::ImGuiViewportP* viewport, const cimgui::ImDrawList* draw_list, const char* label) +{ + ::ImGui::DebugNodeDrawList(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiViewportP*>(viewport), reinterpret_cast(draw_list), label); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeDrawCmdShowMeshAndBoundingBox(cimgui::ImDrawList* out_draw_list, const cimgui::ImDrawList* draw_list, const cimgui::ImDrawCmd* draw_cmd, bool show_mesh, bool show_aabb) +{ + ::ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(reinterpret_cast<::ImDrawList*>(out_draw_list), reinterpret_cast(draw_list), reinterpret_cast(draw_cmd), show_mesh, show_aabb); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeFont(cimgui::ImFont* font) +{ + ::ImGui::DebugNodeFont(reinterpret_cast<::ImFont*>(font)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeFontGlyphesForSrcMask(cimgui::ImFont* font, cimgui::ImFontBaked* baked, int src_mask) +{ + ::ImGui::DebugNodeFontGlyphesForSrcMask(reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontBaked*>(baked), src_mask); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeFontGlyph(cimgui::ImFont* font, const cimgui::ImFontGlyph* glyph) +{ + ::ImGui::DebugNodeFontGlyph(reinterpret_cast<::ImFont*>(font), reinterpret_cast(glyph)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeTexture(cimgui::ImTextureData* tex, int int_id) +{ + ::ImGui::DebugNodeTexture(reinterpret_cast<::ImTextureData*>(tex), int_id); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeTextureEx(cimgui::ImTextureData* tex, int int_id, const cimgui::ImFontAtlasRect* highlight_rect) +{ + ::ImGui::DebugNodeTexture(reinterpret_cast<::ImTextureData*>(tex), int_id, reinterpret_cast(highlight_rect)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeStorage(cimgui::ImGuiStorage* storage, const char* label) +{ + ::ImGui::DebugNodeStorage(reinterpret_cast<::ImGuiStorage*>(storage), label); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeTabBar(cimgui::ImGuiTabBar* tab_bar, const char* label) +{ + ::ImGui::DebugNodeTabBar(reinterpret_cast<::ImGuiTabBar*>(tab_bar), label); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeTable(cimgui::ImGuiTable* table) +{ + ::ImGui::DebugNodeTable(reinterpret_cast<::ImGuiTable*>(table)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeTableSettings(cimgui::ImGuiTableSettings* settings) +{ + ::ImGui::DebugNodeTableSettings(reinterpret_cast<::ImGuiTableSettings*>(settings)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeTypingSelectState(cimgui::ImGuiTypingSelectState* state) +{ + ::ImGui::DebugNodeTypingSelectState(reinterpret_cast<::ImGuiTypingSelectState*>(state)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeMultiSelectState(cimgui::ImGuiMultiSelectState* state) +{ + ::ImGui::DebugNodeMultiSelectState(reinterpret_cast<::ImGuiMultiSelectState*>(state)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeWindow(cimgui::ImGuiWindow* window, const char* label) +{ + ::ImGui::DebugNodeWindow(reinterpret_cast<::ImGuiWindow*>(window), label); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeWindowSettings(cimgui::ImGuiWindowSettings* settings) +{ + ::ImGui::DebugNodeWindowSettings(reinterpret_cast<::ImGuiWindowSettings*>(settings)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeWindowsList(cimgui::ImVector_ImGuiWindowPtr* windows, const char* label) +{ + ::ImGui::DebugNodeWindowsList(reinterpret_cast<::ImVector<::ImGuiWindow*>*>(windows), label); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeWindowsListByBeginStackParent(cimgui::ImGuiWindow** windows, int windows_size, cimgui::ImGuiWindow* parent_in_begin_stack) +{ + ::ImGui::DebugNodeWindowsListByBeginStackParent(reinterpret_cast<::ImGuiWindow**>(windows), windows_size, reinterpret_cast<::ImGuiWindow*>(parent_in_begin_stack)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodeViewport(cimgui::ImGuiViewportP* viewport) +{ + ::ImGui::DebugNodeViewport(reinterpret_cast<::ImGuiViewportP*>(viewport)); +} + +CIMGUI_API void cimgui::ImGui_DebugNodePlatformMonitor(cimgui::ImGuiPlatformMonitor* monitor, const char* label, int idx) +{ + ::ImGui::DebugNodePlatformMonitor(reinterpret_cast<::ImGuiPlatformMonitor*>(monitor), label, idx); +} + +CIMGUI_API void cimgui::ImGui_DebugRenderKeyboardPreview(cimgui::ImDrawList* draw_list) +{ + ::ImGui::DebugRenderKeyboardPreview(reinterpret_cast<::ImDrawList*>(draw_list)); +} + +CIMGUI_API void cimgui::ImGui_DebugRenderViewportThumbnail(cimgui::ImDrawList* draw_list, cimgui::ImGuiViewportP* viewport, cimgui::ImRect bb) +{ + ::ImGui::DebugRenderViewportThumbnail(reinterpret_cast<::ImDrawList*>(draw_list), reinterpret_cast<::ImGuiViewportP*>(viewport), ConvertToCPP_ImRect(bb)); +} + +#ifdef IMGUI_ENABLE_STB_TRUETYPE + +CIMGUI_API const cimgui::ImFontLoader* cimgui::cImFontAtlasGetFontLoaderForStbTruetype(void) +{ + return reinterpret_cast(::ImFontAtlasGetFontLoaderForStbTruetype()); +} + +#endif // #ifdef IMGUI_ENABLE_STB_TRUETYPE + +CIMGUI_API int cimgui::cImFontAtlasRectId_GetIndex(ImFontAtlasRectId id) +{ + return ::ImFontAtlasRectId_GetIndex(id); +} + +CIMGUI_API int cimgui::cImFontAtlasRectId_GetGeneration(ImFontAtlasRectId id) +{ + return ::ImFontAtlasRectId_GetGeneration(id); +} + +CIMGUI_API ImFontAtlasRectId cimgui::cImFontAtlasRectId_Make(int index_idx, int gen_idx) +{ + return ::ImFontAtlasRectId_Make(index_idx, gen_idx); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildInit(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasBuildInit(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildDestroy(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasBuildDestroy(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildMain(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasBuildMain(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildSetupFontLoader(cimgui::ImFontAtlas* atlas, const cimgui::ImFontLoader* font_loader) +{ + ::ImFontAtlasBuildSetupFontLoader(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast(font_loader)); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildUpdatePointers(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasBuildUpdatePointers(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildRenderBitmapFromString(cimgui::ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char) +{ + ::ImFontAtlasBuildRenderBitmapFromString(reinterpret_cast<::ImFontAtlas*>(atlas), x, y, w, h, in_str, in_marker_char); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildClear(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasBuildClear(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API cimgui::ImTextureData* cimgui::cImFontAtlasTextureAdd(cimgui::ImFontAtlas* atlas, int w, int h) +{ + return reinterpret_cast<::cimgui::ImTextureData*>(::ImFontAtlasTextureAdd(reinterpret_cast<::ImFontAtlas*>(atlas), w, h)); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureMakeSpace(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasTextureMakeSpace(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureRepack(cimgui::ImFontAtlas* atlas, int w, int h) +{ + ::ImFontAtlasTextureRepack(reinterpret_cast<::ImFontAtlas*>(atlas), w, h); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureGrow(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasTextureGrow(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureGrowEx(cimgui::ImFontAtlas* atlas, int old_w, int old_h) +{ + ::ImFontAtlasTextureGrow(reinterpret_cast<::ImFontAtlas*>(atlas), old_w, old_h); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureCompact(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasTextureCompact(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API cimgui::ImVec2i cimgui::cImFontAtlasTextureGetSizeEstimate(cimgui::ImFontAtlas* atlas) +{ + return ConvertFromCPP_ImVec2i(::ImFontAtlasTextureGetSizeEstimate(reinterpret_cast<::ImFontAtlas*>(atlas))); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildSetupFontSpecialGlyphs(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontConfig* src) +{ + ::ImFontAtlasBuildSetupFontSpecialGlyphs(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontConfig*>(src)); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildLegacyPreloadAllGlyphRanges(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasBuildLegacyPreloadAllGlyphRanges(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildGetOversampleFactors(cimgui::ImFontConfig* src, cimgui::ImFontBaked* baked, int* out_oversample_h, int* out_oversample_v) +{ + ::ImFontAtlasBuildGetOversampleFactors(reinterpret_cast<::ImFontConfig*>(src), reinterpret_cast<::ImFontBaked*>(baked), out_oversample_h, out_oversample_v); +} + +CIMGUI_API void cimgui::cImFontAtlasBuildDiscardBakes(cimgui::ImFontAtlas* atlas, int unused_frames) +{ + ::ImFontAtlasBuildDiscardBakes(reinterpret_cast<::ImFontAtlas*>(atlas), unused_frames); +} + +CIMGUI_API bool cimgui::cImFontAtlasFontSourceInit(cimgui::ImFontAtlas* atlas, cimgui::ImFontConfig* src) +{ + return ::ImFontAtlasFontSourceInit(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontConfig*>(src)); +} + +CIMGUI_API void cimgui::cImFontAtlasFontSourceAddToFont(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontConfig* src) +{ + ::ImFontAtlasFontSourceAddToFont(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontConfig*>(src)); +} + +CIMGUI_API void cimgui::cImFontAtlasFontDestroySourceData(cimgui::ImFontAtlas* atlas, cimgui::ImFontConfig* src) +{ + ::ImFontAtlasFontDestroySourceData(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontConfig*>(src)); +} + +CIMGUI_API bool cimgui::cImFontAtlasFontInitOutput(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font) +{ + return ::ImFontAtlasFontInitOutput(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font)); +} + +CIMGUI_API void cimgui::cImFontAtlasFontDestroyOutput(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font) +{ + ::ImFontAtlasFontDestroyOutput(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font)); +} + +CIMGUI_API void cimgui::cImFontAtlasFontDiscardBakes(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, int unused_frames) +{ + ::ImFontAtlasFontDiscardBakes(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), unused_frames); +} + +CIMGUI_API ImGuiID cimgui::cImFontAtlasBakedGetId(ImGuiID font_id, float baked_size, float rasterizer_density) +{ + return ::ImFontAtlasBakedGetId(font_id, baked_size, rasterizer_density); +} + +CIMGUI_API cimgui::ImFontBaked* cimgui::cImFontAtlasBakedGetOrAdd(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, float font_size, float font_rasterizer_density) +{ + return reinterpret_cast<::cimgui::ImFontBaked*>(::ImFontAtlasBakedGetOrAdd(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), font_size, font_rasterizer_density)); +} + +CIMGUI_API cimgui::ImFontBaked* cimgui::cImFontAtlasBakedGetClosestMatch(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, float font_size, float font_rasterizer_density) +{ + return reinterpret_cast<::cimgui::ImFontBaked*>(::ImFontAtlasBakedGetClosestMatch(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), font_size, font_rasterizer_density)); +} + +CIMGUI_API cimgui::ImFontBaked* cimgui::cImFontAtlasBakedAdd(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, float font_size, float font_rasterizer_density, ImGuiID baked_id) +{ + return reinterpret_cast<::cimgui::ImFontBaked*>(::ImFontAtlasBakedAdd(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), font_size, font_rasterizer_density, baked_id)); +} + +CIMGUI_API void cimgui::cImFontAtlasBakedDiscard(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontBaked* baked) +{ + ::ImFontAtlasBakedDiscard(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontBaked*>(baked)); +} + +CIMGUI_API cimgui::ImFontGlyph* cimgui::cImFontAtlasBakedAddFontGlyph(cimgui::ImFontAtlas* atlas, cimgui::ImFontBaked* baked, cimgui::ImFontConfig* src, const cimgui::ImFontGlyph* in_glyph) +{ + return reinterpret_cast<::cimgui::ImFontGlyph*>(::ImFontAtlasBakedAddFontGlyph(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontConfig*>(src), reinterpret_cast(in_glyph))); +} + +CIMGUI_API void cimgui::cImFontAtlasBakedAddFontGlyphAdvancedX(cimgui::ImFontAtlas* atlas, cimgui::ImFontBaked* baked, cimgui::ImFontConfig* src, ImWchar codepoint, float advance_x) +{ + ::ImFontAtlasBakedAddFontGlyphAdvancedX(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontConfig*>(src), codepoint, advance_x); +} + +CIMGUI_API void cimgui::cImFontAtlasBakedDiscardFontGlyph(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontBaked* baked, cimgui::ImFontGlyph* glyph) +{ + ::ImFontAtlasBakedDiscardFontGlyph(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontGlyph*>(glyph)); +} + +CIMGUI_API void cimgui::cImFontAtlasBakedSetFontGlyphBitmap(cimgui::ImFontAtlas* atlas, cimgui::ImFontBaked* baked, cimgui::ImFontConfig* src, cimgui::ImFontGlyph* glyph, cimgui::ImTextureRect* r, const unsigned char* src_pixels, cimgui::ImTextureFormat src_fmt, int src_pitch) +{ + ::ImFontAtlasBakedSetFontGlyphBitmap(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontConfig*>(src), reinterpret_cast<::ImFontGlyph*>(glyph), reinterpret_cast<::ImTextureRect*>(r), src_pixels, static_cast<::ImTextureFormat>(src_fmt), src_pitch); +} + +CIMGUI_API void cimgui::cImFontAtlasPackInit(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasPackInit(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API ImFontAtlasRectId cimgui::cImFontAtlasPackAddRect(cimgui::ImFontAtlas* atlas, int w, int h) +{ + return ::ImFontAtlasPackAddRect(reinterpret_cast<::ImFontAtlas*>(atlas), w, h); +} + +CIMGUI_API ImFontAtlasRectId cimgui::cImFontAtlasPackAddRectEx(cimgui::ImFontAtlas* atlas, int w, int h, cimgui::ImFontAtlasRectEntry* overwrite_entry) +{ + return ::ImFontAtlasPackAddRect(reinterpret_cast<::ImFontAtlas*>(atlas), w, h, reinterpret_cast<::ImFontAtlasRectEntry*>(overwrite_entry)); +} + +CIMGUI_API cimgui::ImTextureRect* cimgui::cImFontAtlasPackGetRect(cimgui::ImFontAtlas* atlas, ImFontAtlasRectId id) +{ + return reinterpret_cast<::cimgui::ImTextureRect*>(::ImFontAtlasPackGetRect(reinterpret_cast<::ImFontAtlas*>(atlas), id)); +} + +CIMGUI_API cimgui::ImTextureRect* cimgui::cImFontAtlasPackGetRectSafe(cimgui::ImFontAtlas* atlas, ImFontAtlasRectId id) +{ + return reinterpret_cast<::cimgui::ImTextureRect*>(::ImFontAtlasPackGetRectSafe(reinterpret_cast<::ImFontAtlas*>(atlas), id)); +} + +CIMGUI_API void cimgui::cImFontAtlasPackDiscardRect(cimgui::ImFontAtlas* atlas, ImFontAtlasRectId id) +{ + ::ImFontAtlasPackDiscardRect(reinterpret_cast<::ImFontAtlas*>(atlas), id); +} + +CIMGUI_API void cimgui::cImFontAtlasUpdateNewFrame(cimgui::ImFontAtlas* atlas, int frame_count, bool renderer_has_textures) +{ + ::ImFontAtlasUpdateNewFrame(reinterpret_cast<::ImFontAtlas*>(atlas), frame_count, renderer_has_textures); +} + +CIMGUI_API void cimgui::cImFontAtlasAddDrawListSharedData(cimgui::ImFontAtlas* atlas, cimgui::ImDrawListSharedData* data) +{ + ::ImFontAtlasAddDrawListSharedData(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImDrawListSharedData*>(data)); +} + +CIMGUI_API void cimgui::cImFontAtlasRemoveDrawListSharedData(cimgui::ImFontAtlas* atlas, cimgui::ImDrawListSharedData* data) +{ + ::ImFontAtlasRemoveDrawListSharedData(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImDrawListSharedData*>(data)); +} + +CIMGUI_API void cimgui::cImFontAtlasUpdateDrawListsTextures(cimgui::ImFontAtlas* atlas, cimgui::ImTextureRef old_tex, cimgui::ImTextureRef new_tex) +{ + ::ImFontAtlasUpdateDrawListsTextures(reinterpret_cast<::ImFontAtlas*>(atlas), ConvertToCPP_ImTextureRef(old_tex), ConvertToCPP_ImTextureRef(new_tex)); +} + +CIMGUI_API void cimgui::cImFontAtlasUpdateDrawListsSharedData(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasUpdateDrawListsSharedData(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureBlockConvert(const unsigned char* src_pixels, cimgui::ImTextureFormat src_fmt, int src_pitch, unsigned char* dst_pixels, cimgui::ImTextureFormat dst_fmt, int dst_pitch, int w, int h) +{ + ::ImFontAtlasTextureBlockConvert(src_pixels, static_cast<::ImTextureFormat>(src_fmt), src_pitch, dst_pixels, static_cast<::ImTextureFormat>(dst_fmt), dst_pitch, w, h); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureBlockPostProcess(cimgui::ImFontAtlasPostProcessData* data) +{ + ::ImFontAtlasTextureBlockPostProcess(reinterpret_cast<::ImFontAtlasPostProcessData*>(data)); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureBlockPostProcessMultiply(cimgui::ImFontAtlasPostProcessData* data, float multiply_factor) +{ + ::ImFontAtlasTextureBlockPostProcessMultiply(reinterpret_cast<::ImFontAtlasPostProcessData*>(data), multiply_factor); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureBlockFill(cimgui::ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h, ImU32 col) +{ + ::ImFontAtlasTextureBlockFill(reinterpret_cast<::ImTextureData*>(dst_tex), dst_x, dst_y, w, h, col); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureBlockCopy(cimgui::ImTextureData* src_tex, int src_x, int src_y, cimgui::ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h) +{ + ::ImFontAtlasTextureBlockCopy(reinterpret_cast<::ImTextureData*>(src_tex), src_x, src_y, reinterpret_cast<::ImTextureData*>(dst_tex), dst_x, dst_y, w, h); +} + +CIMGUI_API void cimgui::cImFontAtlasTextureBlockQueueUpload(cimgui::ImFontAtlas* atlas, cimgui::ImTextureData* tex, int x, int y, int w, int h) +{ + ::ImFontAtlasTextureBlockQueueUpload(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImTextureData*>(tex), x, y, w, h); +} + +CIMGUI_API int cimgui::cImTextureDataGetFormatBytesPerPixel(cimgui::ImTextureFormat format) +{ + return ::ImTextureDataGetFormatBytesPerPixel(static_cast<::ImTextureFormat>(format)); +} + +CIMGUI_API const char* cimgui::cImTextureDataGetStatusName(cimgui::ImTextureStatus status) +{ + return ::ImTextureDataGetStatusName(static_cast<::ImTextureStatus>(status)); +} + +CIMGUI_API const char* cimgui::cImTextureDataGetFormatName(cimgui::ImTextureFormat format) +{ + return ::ImTextureDataGetFormatName(static_cast<::ImTextureFormat>(format)); +} + +#ifndef IMGUI_DISABLE_DEBUG_TOOLS + +CIMGUI_API void cimgui::cImFontAtlasDebugLogTextureRequests(cimgui::ImFontAtlas* atlas) +{ + ::ImFontAtlasDebugLogTextureRequests(reinterpret_cast<::ImFontAtlas*>(atlas)); +} + +#endif // #ifndef IMGUI_DISABLE_DEBUG_TOOLS + +CIMGUI_API bool cimgui::cImFontAtlasGetMouseCursorTexData(cimgui::ImFontAtlas* atlas, ImGuiMouseCursor cursor_type, cimgui::ImVec2* out_offset, cimgui::ImVec2* out_size, cimgui::ImVec2 out_uv_border[2], cimgui::ImVec2 out_uv_fill[2]) +{ + ::ImVec2 out_uv_border_converted_array[2]; + for (int i=0; i<2; i++) + out_uv_border_converted_array[i] = ConvertToCPP_ImVec2(out_uv_border[i]); + ::ImVec2 out_uv_fill_converted_array[2]; + for (int i=0; i<2; i++) + out_uv_fill_converted_array[i] = ConvertToCPP_ImVec2(out_uv_fill[i]); + return ::ImFontAtlasGetMouseCursorTexData(reinterpret_cast<::ImFontAtlas*>(atlas), cursor_type, reinterpret_cast<::ImVec2*>(out_offset), reinterpret_cast<::ImVec2*>(out_size), out_uv_border_converted_array, out_uv_fill_converted_array); +} + +#ifdef IMGUI_ENABLE_TEST_ENGINE + +CIMGUI_API void cimgui::cImGuiTestEngineHook_ItemAdd(cimgui::ImGuiContext* ctx, ImGuiID id, cimgui::ImRect bb, const cimgui::ImGuiLastItemData* item_data) +{ + ::ImGuiTestEngineHook_ItemAdd(reinterpret_cast<::ImGuiContext*>(ctx), id, ConvertToCPP_ImRect(bb), reinterpret_cast(item_data)); +} + +CIMGUI_API void cimgui::cImGuiTestEngineHook_ItemInfo(cimgui::ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags) +{ + ::ImGuiTestEngineHook_ItemInfo(reinterpret_cast<::ImGuiContext*>(ctx), id, label, flags); +} + +CIMGUI_API void cimgui::cImGuiTestEngineHook_Log(cimgui::ImGuiContext* ctx, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + ::ImGuiTestEngineHook_LogV(reinterpret_cast<::ImGuiContext*>(ctx), fmt, args); + va_end(args); +} + +CIMGUI_API const char* cimgui::cImGuiTestEngine_FindItemDebugLabel(cimgui::ImGuiContext* ctx, ImGuiID id) +{ + return ::ImGuiTestEngine_FindItemDebugLabel(reinterpret_cast<::ImGuiContext*>(ctx), id); +} + +#endif // #ifdef IMGUI_ENABLE_TEST_ENGINE +#endif // #ifndef IMGUI_DISABLE diff --git a/src/cached/dcimgui_internal.h b/src/cached/dcimgui_internal.h new file mode 100644 index 0000000..e319012 --- /dev/null +++ b/src/cached/dcimgui_internal.h @@ -0,0 +1,4142 @@ +// THIS FILE HAS BEEN AUTO-GENERATED BY THE 'DEAR BINDINGS' GENERATOR. +// **DO NOT EDIT DIRECTLY** +// https://github.com/dearimgui/dear_bindings + +// dear imgui, v1.92.2b +struct ImVector_ImFontBakedPtr_t { int Size; int Capacity; ImFontBaked** Data; }; // Instantiation of ImVector +struct ImVector_ImFontAtlasPtr_t { int Size; int Capacity; ImFontAtlas** Data; }; // Instantiation of ImVector +// (internal structures/api) + +// You may use this file to debug, understand or extend Dear ImGui features but we don't provide any guarantee of forward compatibility. + +/* + +Index of this file: + +// [SECTION] Header mess +// [SECTION] Forward declarations +// [SECTION] Context pointer +// [SECTION] STB libraries includes +// [SECTION] Macros +// [SECTION] Generic helpers +// [SECTION] ImDrawList support +// [SECTION] Style support +// [SECTION] Data types support +// [SECTION] Widgets support: flags, enums, data structures +// [SECTION] Popup support +// [SECTION] Inputs support +// [SECTION] Clipper support +// [SECTION] Navigation support +// [SECTION] Typing-select support +// [SECTION] Columns support +// [SECTION] Box-select support +// [SECTION] Multi-select support +// [SECTION] Docking support +// [SECTION] Viewport support +// [SECTION] Settings support +// [SECTION] Localization support +// [SECTION] Error handling, State recovery support +// [SECTION] Metrics, Debug tools +// [SECTION] Generic context hooks +// [SECTION] ImGuiContext (main imgui context) +// [SECTION] ImGuiWindowTempData, ImGuiWindow +// [SECTION] Tab bar, Tab item support +// [SECTION] Table support +// [SECTION] ImGui internal API +// [SECTION] ImFontLoader +// [SECTION] ImFontAtlas internal API +// [SECTION] Test Engine specific hooks (imgui_test_engine) + +*/ + +#pragma once + +#ifdef __cplusplus +extern "C" +{ +#endif +#ifndef IMGUI_DISABLE +//----------------------------------------------------------------------------- +// [SECTION] Header mess +//----------------------------------------------------------------------------- + +#ifndef IMGUI_VERSION +#include "imgui.h" +#endif // #ifndef IMGUI_VERSION +#include +#include +#include +#include +// Enable SSE intrinsics if available +#if (defined __SSE__ || defined __x86_64__ || defined _M_X64 ||(defined(_M_IX86_FP)&&(_M_IX86_FP >= 1)))&&!defined(IMGUI_DISABLE_SSE) +#define IMGUI_ENABLE_SSE +#include +#if (defined __AVX__ || defined __SSE4_2__) +#define IMGUI_ENABLE_SSE4_2 +#include +#endif // #if (defined __AVX__ || defined __SSE4_2__) +#endif // #if (defined __SSE__ || defined __x86_64__ || defined _M_X64 ||(defined(_M_IX86_FP)&&(_M_IX86_FP >= 1)))&&!defined(IMGUI_DISABLE_SSE) +// Emscripten has partial SSE 4.2 support where _mm_crc32_u32 is not available. See https://emscripten.org/docs/porting/simd.html#id11 and #8213 +#if defined(IMGUI_ENABLE_SSE4_2)&&!defined(IMGUI_USE_LEGACY_CRC32_ADLER)&&!defined(__EMSCRIPTEN__) +#define IMGUI_ENABLE_SSE4_2_CRC +#endif // #if defined(IMGUI_ENABLE_SSE4_2)&&!defined(IMGUI_USE_LEGACY_CRC32_ADLER)&&!defined(__EMSCRIPTEN__) +// Visual Studio warnings +#ifdef _MSC_VER +#pragma warning (push) +#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) +#pragma warning (disable: 26812) // The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3). [MSVC Static Analyzer) +#pragma warning (disable: 26495) // [Static Analyzer] Variable 'XXX' is uninitialized. Always initialize a member variable (type.6). +#if defined(_MSC_VER)&& _MSC_VER >= 1922 +#pragma warning (disable: 5054) // operator '|': deprecated between enumerations of different types +#endif// MSVC 2019 16.2 or later +#endif // #ifdef _MSC_VER +// Clang/GCC warnings with -Weverything +#if defined(__clang__) +#pragma clang diagnostic push +#if __has_warning("-Wunknown-warning-option") +#pragma clang diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx' +#endif // #if __has_warning("-Wunknown-warning-option") +#pragma clang diagnostic ignored "-Wunknown-pragmas" // warning: unknown warning group 'xxx' +#pragma clang diagnostic ignored "-Wfloat-equal" // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants ok, for ImFloor() +#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" // warning: zero as null pointer constant +#pragma clang diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function +#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision +#pragma clang diagnostic ignored "-Wmissing-noreturn" // warning: function 'xxx' could be declared with attribute 'noreturn' +#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated +#pragma clang diagnostic ignored "-Wunsafe-buffer-usage" // warning: 'xxx' is an unsafe pointer used for buffer access +#pragma clang diagnostic ignored "-Wnontrivial-memaccess" // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type +#else +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind +#pragma GCC diagnostic ignored "-Wfloat-equal" // warning: comparing floating-point with '==' or '!=' is unsafe +#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 +#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated +#endif // #if defined(__GNUC__) +#endif // #if defined(__clang__) +// In 1.89.4, we moved the implementation of "courtesy maths operators" from imgui_internal.h in imgui.h +// As they are frequently requested, we do not want to encourage to many people using imgui_internal.h +#if defined(IMGUI_DEFINE_MATH_OPERATORS)&&!defined(IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED) +#error Please '#define IMGUI_DEFINE_MATH_OPERATORS' _BEFORE_ including imgui.h! +#endif // #if defined(IMGUI_DEFINE_MATH_OPERATORS)&&!defined(IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED) +// Legacy defines +#ifdef IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS +#error Use IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS +#endif// Renamed in 1.74 +#ifdef IMGUI_DISABLE_MATH_FUNCTIONS +#error Use IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS +#endif// Renamed in 1.74 +// Enable stb_truetype by default unless FreeType is enabled. +// You can compile with both by defining both IMGUI_ENABLE_FREETYPE and IMGUI_ENABLE_STB_TRUETYPE together. +#ifndef IMGUI_ENABLE_FREETYPE +#define IMGUI_ENABLE_STB_TRUETYPE +#endif // #ifndef IMGUI_ENABLE_FREETYPE +//----------------------------------------------------------------------------- +// [SECTION] Forward declarations +// Auto-generated forward declarations for C header +typedef struct ImVector_ImFontBakedPtr_t ImVector_ImFontBakedPtr; +typedef struct ImVector_ImFontAtlasPtr_t ImVector_ImFontAtlasPtr; +typedef struct ImVec1_t ImVec1; +typedef struct ImVec2i_t ImVec2i; +typedef struct ImVec2ih_t ImVec2ih; +typedef struct ImSpan_ImGuiTableColumn_t ImSpan_ImGuiTableColumn; +typedef struct ImSpan_ImGuiTableColumnIdx_t ImSpan_ImGuiTableColumnIdx; +typedef struct ImSpan_ImGuiTableCellData_t ImSpan_ImGuiTableCellData; +typedef struct ImStableVector_ImFontBaked_32_t ImStableVector_ImFontBaked_32; +typedef struct ImFontStackData_t ImFontStackData; +typedef struct ImVector_ImFontStackData_t ImVector_ImFontStackData; +typedef struct ImGuiDataTypeStorage_t ImGuiDataTypeStorage; +typedef struct ImChunkStream_ImGuiTableSettings_t ImChunkStream_ImGuiTableSettings; +typedef struct ImChunkStream_ImGuiWindowSettings_t ImChunkStream_ImGuiWindowSettings; +typedef struct ImVector_unsigned_char_t ImVector_unsigned_char; +typedef struct ImVector_ImGuiWindowStackData_t ImVector_ImGuiWindowStackData; +typedef struct ImVector_ImGuiWindowPtr_t ImVector_ImGuiWindowPtr; +typedef struct ImVector_ImGuiViewportPPtr_t ImVector_ImGuiViewportPPtr; +typedef struct ImVector_ImGuiTreeNodeStackData_t ImVector_ImGuiTreeNodeStackData; +typedef struct ImVector_ImGuiTableTempData_t ImVector_ImGuiTableTempData; +typedef struct ImVector_ImGuiTableInstanceData_t ImVector_ImGuiTableInstanceData; +typedef struct ImVector_ImGuiTableHeaderData_t ImVector_ImGuiTableHeaderData; +typedef struct ImVector_ImGuiTableColumnSortSpecs_t ImVector_ImGuiTableColumnSortSpecs; +typedef struct ImVector_ImGuiTable_t ImVector_ImGuiTable; +typedef struct ImVector_ImGuiTabItem_t ImVector_ImGuiTabItem; +typedef struct ImVector_ImGuiTabBar_t ImVector_ImGuiTabBar; +typedef struct ImVector_ImGuiStyleMod_t ImVector_ImGuiStyleMod; +typedef struct ImVector_ImGuiStackLevelInfo_t ImVector_ImGuiStackLevelInfo; +typedef struct ImVector_ImGuiShrinkWidthItem_t ImVector_ImGuiShrinkWidthItem; +typedef struct ImVector_ImGuiSettingsHandler_t ImVector_ImGuiSettingsHandler; +typedef struct ImVector_ImGuiPtrOrIndex_t ImVector_ImGuiPtrOrIndex; +typedef struct ImVector_ImGuiPopupData_t ImVector_ImGuiPopupData; +typedef struct ImVector_ImGuiOldColumns_t ImVector_ImGuiOldColumns; +typedef struct ImVector_ImGuiOldColumnData_t ImVector_ImGuiOldColumnData; +typedef struct ImVector_ImGuiMultiSelectTempData_t ImVector_ImGuiMultiSelectTempData; +typedef struct ImVector_ImGuiMultiSelectState_t ImVector_ImGuiMultiSelectState; +typedef struct ImVector_ImGuiListClipperRange_t ImVector_ImGuiListClipperRange; +typedef struct ImVector_ImGuiListClipperData_t ImVector_ImGuiListClipperData; +typedef struct ImVector_ImGuiKeyRoutingData_t ImVector_ImGuiKeyRoutingData; +typedef struct ImVector_ImGuiItemFlags_t ImVector_ImGuiItemFlags; +typedef struct ImVector_ImGuiInputEvent_t ImVector_ImGuiInputEvent; +typedef struct ImVector_ImGuiID_t ImVector_ImGuiID; +typedef struct ImVector_ImGuiGroupData_t ImVector_ImGuiGroupData; +typedef struct ImVector_ImGuiFocusScopeData_t ImVector_ImGuiFocusScopeData; +typedef struct ImVector_ImGuiDockRequest_t ImVector_ImGuiDockRequest; +typedef struct ImVector_ImGuiDockNodeSettings_t ImVector_ImGuiDockNodeSettings; +typedef struct ImVector_ImGuiContextHook_t ImVector_ImGuiContextHook; +typedef struct ImVector_ImGuiColorMod_t ImVector_ImGuiColorMod; +typedef struct ImVector_const_charPtr_t ImVector_const_charPtr; +typedef struct ImVector_int_t ImVector_int; +typedef struct ImPool_ImGuiMultiSelectState_t ImPool_ImGuiMultiSelectState; +typedef struct ImPool_ImGuiTabBar_t ImPool_ImGuiTabBar; +typedef struct ImPool_ImGuiTable_t ImPool_ImGuiTable; +typedef struct ImGuiTextIndex_t ImGuiTextIndex; +typedef struct ImGuiComboPreviewData_t ImGuiComboPreviewData; +typedef struct ImGuiInputTextDeactivatedState_t ImGuiInputTextDeactivatedState; +typedef struct ImGuiWindowStackData_t ImGuiWindowStackData; +typedef struct ImGuiShrinkWidthItem_t ImGuiShrinkWidthItem; +typedef struct ImGuiPtrOrIndex_t ImGuiPtrOrIndex; +typedef struct ImGuiInputEventMousePos_t ImGuiInputEventMousePos; +typedef struct ImGuiInputEventMouseWheel_t ImGuiInputEventMouseWheel; +typedef struct ImGuiInputEventMouseButton_t ImGuiInputEventMouseButton; +typedef struct ImGuiInputEventMouseViewport_t ImGuiInputEventMouseViewport; +typedef struct ImGuiInputEventKey_t ImGuiInputEventKey; +typedef struct ImGuiInputEventText_t ImGuiInputEventText; +typedef struct ImGuiInputEventAppFocused_t ImGuiInputEventAppFocused; +typedef struct ImGuiInputEvent_t ImGuiInputEvent; +typedef struct ImGuiKeyRoutingData_t ImGuiKeyRoutingData; +typedef struct ImGuiKeyRoutingTable_t ImGuiKeyRoutingTable; +typedef struct ImGuiKeyOwnerData_t ImGuiKeyOwnerData; +typedef struct ImGuiListClipperRange_t ImGuiListClipperRange; +typedef struct ImGuiListClipperData_t ImGuiListClipperData; +typedef struct ImGuiFocusScopeData_t ImGuiFocusScopeData; +typedef struct ImGuiViewportP_t ImGuiViewportP; +typedef struct ImGuiDebugAllocEntry_t ImGuiDebugAllocEntry; +typedef struct ImGuiDebugAllocInfo_t ImGuiDebugAllocInfo; +typedef struct ImGuiStackLevelInfo_t ImGuiStackLevelInfo; +typedef struct ImGuiIDStackTool_t ImGuiIDStackTool; +typedef struct ImGuiTableCellData_t ImGuiTableCellData; +typedef struct ImGuiTableColumnSettings_t ImGuiTableColumnSettings; +typedef struct ImVector_ImFontAtlasRectEntry_t ImVector_ImFontAtlasRectEntry; +typedef struct ImVector_stbrp_node_im_t ImVector_stbrp_node_im; +typedef struct stbrp_context_opaque_t stbrp_context_opaque; +// Table column indexing +typedef ImS16 ImGuiTableColumnIdx; +//----------------------------------------------------------------------------- + +// Utilities +// (other types which are not forwarded declared are: ImBitArray<>, ImSpan<>, ImSpanAllocator<>, ImStableVector<>, ImPool<>, ImChunkStream<>) +typedef struct ImBitVector_t ImBitVector; // Store 1-bit per value +typedef struct ImRect_t ImRect; // An axis-aligned rectangle (2 points) + +// ImDrawList/ImFontAtlas +typedef struct ImDrawDataBuilder_t ImDrawDataBuilder; // Helper to build a ImDrawData instance +typedef struct ImDrawListSharedData_t ImDrawListSharedData; // Data shared between all ImDrawList instances +typedef struct ImFontAtlasBuilder_t ImFontAtlasBuilder; // Internal storage for incrementally packing and building a ImFontAtlas +typedef struct ImFontAtlasPostProcessData_t ImFontAtlasPostProcessData; // Data available to potential texture post-processing functions +typedef struct ImFontAtlasRectEntry_t ImFontAtlasRectEntry; // Packed rectangle lookup entry + +// ImGui +typedef struct ImGuiBoxSelectState_t ImGuiBoxSelectState; // Box-selection state (currently used by multi-selection, could potentially be used by others) +typedef struct ImGuiColorMod_t ImGuiColorMod; // Stacked color modifier, backup of modified data so we can restore it +typedef struct ImGuiContext_t ImGuiContext; // Main Dear ImGui context +typedef struct ImGuiContextHook_t ImGuiContextHook; // Hook for extensions like ImGuiTestEngine +typedef struct ImGuiDataTypeInfo_t ImGuiDataTypeInfo; // Type information associated to a ImGuiDataType enum +typedef struct ImGuiDeactivatedItemData_t ImGuiDeactivatedItemData; // Data for IsItemDeactivated()/IsItemDeactivatedAfterEdit() function. +typedef struct ImGuiDockContext_t ImGuiDockContext; // Docking system context +typedef struct ImGuiDockRequest_t ImGuiDockRequest; // Docking system dock/undock queued request +typedef struct ImGuiDockNode_t ImGuiDockNode; // Docking system node (hold a list of Windows OR two child dock nodes) +typedef struct ImGuiDockNodeSettings_t ImGuiDockNodeSettings; // Storage for a dock node in .ini file (we preserve those even if the associated dock node isn't active during the session) +typedef struct ImGuiErrorRecoveryState_t ImGuiErrorRecoveryState; // Storage of stack sizes for error handling and recovery +typedef struct ImGuiGroupData_t ImGuiGroupData; // Stacked storage data for BeginGroup()/EndGroup() +typedef struct ImGuiInputTextState_t ImGuiInputTextState; // Internal state of the currently focused/edited text input box +typedef struct ImGuiInputTextDeactivateData_t ImGuiInputTextDeactivateData; // Short term storage to backup text of a deactivating InputText() while another is stealing active id +typedef struct ImGuiLastItemData_t ImGuiLastItemData; // Status storage for last submitted items +typedef struct ImGuiLocEntry_t ImGuiLocEntry; // A localization entry. +typedef struct ImGuiMenuColumns_t ImGuiMenuColumns; // Simple column measurement, currently used for MenuItem() only +typedef struct ImGuiMultiSelectState_t ImGuiMultiSelectState; // Multi-selection persistent state (for focused selection). +typedef struct ImGuiMultiSelectTempData_t ImGuiMultiSelectTempData; // Multi-selection temporary state (while traversing). +typedef struct ImGuiNavItemData_t ImGuiNavItemData; // Result of a keyboard/gamepad directional navigation move query result +typedef struct ImGuiMetricsConfig_t ImGuiMetricsConfig; // Storage for ShowMetricsWindow() and DebugNodeXXX() functions +typedef struct ImGuiNextWindowData_t ImGuiNextWindowData; // Storage for SetNextWindow** functions +typedef struct ImGuiNextItemData_t ImGuiNextItemData; // Storage for SetNextItem** functions +typedef struct ImGuiOldColumnData_t ImGuiOldColumnData; // Storage data for a single column for legacy Columns() api +typedef struct ImGuiOldColumns_t ImGuiOldColumns; // Storage data for a columns set for legacy Columns() api +typedef struct ImGuiPopupData_t ImGuiPopupData; // Storage for current popup stack +typedef struct ImGuiSettingsHandler_t ImGuiSettingsHandler; // Storage for one type registered in the .ini file +typedef struct ImGuiStyleMod_t ImGuiStyleMod; // Stacked style modifier, backup of modified data so we can restore it +typedef struct ImGuiStyleVarInfo_t ImGuiStyleVarInfo; // Style variable information (e.g. to access style variables from an enum) +typedef struct ImGuiTabBar_t ImGuiTabBar; // Storage for a tab bar +typedef struct ImGuiTabItem_t ImGuiTabItem; // Storage for a tab item (within a tab bar) +typedef struct ImGuiTable_t ImGuiTable; // Storage for a table +typedef struct ImGuiTableHeaderData_t ImGuiTableHeaderData; // Storage for TableAngledHeadersRow() +typedef struct ImGuiTableColumn_t ImGuiTableColumn; // Storage for one column of a table +typedef struct ImGuiTableInstanceData_t ImGuiTableInstanceData; // Storage for one instance of a same table +typedef struct ImGuiTableTempData_t ImGuiTableTempData; // Temporary storage for one table (one per table in the stack), shared between tables. +typedef struct ImGuiTableSettings_t ImGuiTableSettings; // Storage for a table .ini settings +typedef struct ImGuiTableColumnsSettings_t ImGuiTableColumnsSettings; // Storage for a column .ini settings +typedef struct ImGuiTreeNodeStackData_t ImGuiTreeNodeStackData; // Temporary storage for TreeNode(). +typedef struct ImGuiTypingSelectState_t ImGuiTypingSelectState; // Storage for GetTypingSelectRequest() +typedef struct ImGuiTypingSelectRequest_t ImGuiTypingSelectRequest; // Storage for GetTypingSelectRequest() (aimed to be public) +typedef struct ImGuiWindow_t ImGuiWindow; // Storage for one window +typedef struct ImGuiWindowDockStyle_t ImGuiWindowDockStyle; // Storage for window-style data which needs to be stored for docking purpose +typedef struct ImGuiWindowTempData_t ImGuiWindowTempData; // Temporary storage for one window (that's the data which in theory we could ditch at the end of the frame, in practice we currently keep it for each window) +typedef struct ImGuiWindowSettings_t ImGuiWindowSettings; // Storage for a window .ini settings (we keep one of those even if the actual window wasn't instanced during this session) + +// Enumerations +// Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists. +typedef int ImGuiLocKey; // -> enum ImGuiLocKey // Enum: a localization entry for translation. +typedef int ImGuiDataAuthority; // -> enum ImGuiDataAuthority_ // Enum: for storing the source authority (dock node vs window) of a field +typedef int ImGuiLayoutType; // -> enum ImGuiLayoutType_ // Enum: Horizontal or vertical + +// Flags +typedef int ImGuiActivateFlags; // -> enum ImGuiActivateFlags_ // Flags: for navigation/focus function (will be for ActivateItem() later) +typedef int ImGuiDebugLogFlags; // -> enum ImGuiDebugLogFlags_ // Flags: for ShowDebugLogWindow(), g.DebugLogFlags +typedef int ImGuiFocusRequestFlags; // -> enum ImGuiFocusRequestFlags_ // Flags: for FocusWindow() +typedef int ImGuiItemStatusFlags; // -> enum ImGuiItemStatusFlags_ // Flags: for g.LastItemData.StatusFlags +typedef int ImGuiOldColumnFlags; // -> enum ImGuiOldColumnFlags_ // Flags: for BeginColumns() +typedef int ImGuiLogFlags; // -> enum ImGuiLogFlags_ // Flags: for LogBegin() text capturing function +typedef int ImGuiNavRenderCursorFlags; // -> enum ImGuiNavRenderCursorFlags_//Flags: for RenderNavCursor() +typedef int ImGuiNavMoveFlags; // -> enum ImGuiNavMoveFlags_ // Flags: for navigation requests +typedef int ImGuiNextItemDataFlags; // -> enum ImGuiNextItemDataFlags_ // Flags: for SetNextItemXXX() functions +typedef int ImGuiNextWindowDataFlags; // -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions +typedef int ImGuiScrollFlags; // -> enum ImGuiScrollFlags_ // Flags: for ScrollToItem() and navigation requests +typedef int ImGuiSeparatorFlags; // -> enum ImGuiSeparatorFlags_ // Flags: for SeparatorEx() +typedef int ImGuiTextFlags; // -> enum ImGuiTextFlags_ // Flags: for TextEx() +typedef int ImGuiTooltipFlags; // -> enum ImGuiTooltipFlags_ // Flags: for BeginTooltipEx() +typedef int ImGuiTypingSelectFlags; // -> enum ImGuiTypingSelectFlags_ // Flags: for GetTypingSelectRequest() +typedef int ImGuiWindowRefreshFlags; // -> enum ImGuiWindowRefreshFlags_ // Flags: for SetNextWindowRefreshPolicy() + +typedef ImU16 ImGuiTableDrawChannelIdx; + +//----------------------------------------------------------------------------- +// [SECTION] Context pointer +// See implementation of this variable in imgui.cpp for comments and details. +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// [SECTION] Macros +//----------------------------------------------------------------------------- + +// Internal Drag and Drop payload types. String starting with '_' are reserved for Dear ImGui. +#define IMGUI_PAYLOAD_TYPE_WINDOW "_IMWINDOW" // Payload == ImGuiWindow* + +// Debug Printing Into TTY +// (since IMGUI_VERSION_NUM >= 18729: IMGUI_DEBUG_LOG was reworked into IMGUI_DEBUG_PRINTF (and removed framecount from it). If you were using a #define IMGUI_DEBUG_LOG please rename) +#ifndef IMGUI_DEBUG_PRINTF +#ifndef IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS +#define IMGUI_DEBUG_PRINTF(_FMT,...) printf(_FMT, __VA_ARGS__) +#else +#define IMGUI_DEBUG_PRINTF(_FMT,...) ((void)0) +#endif // #ifndef IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS +#endif // #ifndef IMGUI_DEBUG_PRINTF +// Debug Logging for ShowDebugLogWindow(). This is designed for relatively rare events so please don't spam. +#define IMGUI_DEBUG_LOG_ERROR(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventError) IMGUI_DEBUG_LOG(__VA_ARGS__); else g.DebugLogSkippedErrors++; } while (0) +#define IMGUI_DEBUG_LOG_ACTIVEID(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventActiveId) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_FOCUS(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventFocus) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_POPUP(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventPopup) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_NAV(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventNav) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_SELECTION(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_CLIPPER(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventClipper) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_IO(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventIO) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_FONT(...) do { ImGuiContext* g2 = GImGui; if (g2 && g2->DebugLogFlags & ImGuiDebugLogFlags_EventFont) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) // Called from ImFontAtlas function which may operate without a context. +#define IMGUI_DEBUG_LOG_INPUTROUTING(...) do{if (g.DebugLogFlags & ImGuiDebugLogFlags_EventInputRouting)IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_DOCKING(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventDocking) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) +#define IMGUI_DEBUG_LOG_VIEWPORT(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventViewport) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) + +// Static Asserts +#define IM_STATIC_ASSERT(_COND) static_assert(_COND, "") + +// "Paranoid" Debug Asserts are meant to only be enabled during specific debugging/work, otherwise would slow down the code too much. +// We currently don't have many of those so the effect is currently negligible, but onward intent to add more aggressive ones in the code. +//#define IMGUI_DEBUG_PARANOID +#ifdef IMGUI_DEBUG_PARANOID +#define IM_ASSERT_PARANOID(_EXPR) IM_ASSERT(_EXPR) +#else +#define IM_ASSERT_PARANOID(_EXPR) +#endif // #ifdef IMGUI_DEBUG_PARANOID +// Misc Macros +#define IM_PI 3.14159265358979323846f +#ifdef _WIN32 +#define IM_NEWLINE "\r\n" // Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!) +#else +#define IM_NEWLINE "\n" +#endif // #ifdef _WIN32 +#ifndef IM_TABSIZE +#define IM_TABSIZE (4) +#endif// Until we move this to runtime and/or add proper tab support, at least allow users to compile-time override +#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 +#define IM_F32_TO_INT8_UNBOUND(_VAL) ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f))) // Unsaturated, for display purpose +#define IM_F32_TO_INT8_SAT(_VAL) ((int)(ImSaturate(_VAL) * 255.0f + 0.5f)) // Saturated, always output 0..255 +#define IM_TRUNC(_VAL) ((float)(int)(_VAL)) // ImTrunc() is not inlined in MSVC debug builds +#define IM_ROUND(_VAL) ((float)(int)((_VAL) + 0.5f)) // +#define IM_STRINGIFY_HELPER(_X) #_X +#define IM_STRINGIFY(_X) IM_STRINGIFY_HELPER(_X) // Preprocessor idiom to stringify e.g. an integer. +#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +#define IM_FLOOR IM_TRUNC +#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +// Hint for branch prediction +#if (defined(__cplusplus)&&(__cplusplus >= 202002L))||(defined(_MSVC_LANG)&&(_MSVC_LANG >= 202002L)) +#define IM_LIKELY [[likely]] +#define IM_UNLIKELY [[unlikely]] +#else +#define IM_LIKELY +#define IM_UNLIKELY +#endif // #if (defined(__cplusplus)&&(__cplusplus >= 202002L))||(defined(_MSVC_LANG)&&(_MSVC_LANG >= 202002L)) +// Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall +#ifdef _MSC_VER +#define IMGUI_CDECL __cdecl +#else +#define IMGUI_CDECL +#endif // #ifdef _MSC_VER +// Warnings +#if defined(_MSC_VER)&&!defined(__clang__) +#define IM_MSVC_WARNING_SUPPRESS(XXXX) __pragma(warning(suppress: XXXX)) +#else +#define IM_MSVC_WARNING_SUPPRESS(XXXX) +#endif // #if defined(_MSC_VER)&&!defined(__clang__) +// Debug Tools +// Use 'Metrics/Debugger->Tools->Item Picker' to break into the call-stack of a specific item. +// This will call IM_DEBUG_BREAK() which you may redefine yourself. See https://github.com/scottt/debugbreak for more reference. +#ifndef IM_DEBUG_BREAK +#if defined(_MSC_VER) +#define IM_DEBUG_BREAK() __debugbreak() +#else +#if defined(__clang__) +#define IM_DEBUG_BREAK() __builtin_debugtrap() +#else +#if defined(__GNUC__)&&(defined(__i386__)|| defined(__x86_64__)) +#define IM_DEBUG_BREAK() __asm__ volatile("int3;nop") +#else +#if defined(__GNUC__)&& defined(__thumb__) +#define IM_DEBUG_BREAK() __asm__ volatile(".inst 0xde01") +#else +#if defined(__GNUC__)&& defined(__arm__)&&!defined(__thumb__) +#define IM_DEBUG_BREAK() __asm__ volatile(".inst 0xe7f001f0") +#else +#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! +#endif // #if defined(__GNUC__)&& defined(__arm__)&&!defined(__thumb__) +#endif // #if defined(__GNUC__)&& defined(__thumb__) +#endif // #if defined(__GNUC__)&&(defined(__i386__)|| defined(__x86_64__)) +#endif // #if defined(__clang__) +#endif // #if defined(_MSC_VER) +#endif// #ifndef IM_DEBUG_BREAK +// Format specifiers, printing 64-bit hasn't been decently standardized... +// In a real application you should be using PRId64 and PRIu64 from (non-windows) and on Windows define them yourself. +#if defined(_MSC_VER)&&!defined(__clang__) +#define IM_PRId64 "I64d" +#define IM_PRIu64 "I64u" +#define IM_PRIX64 "I64X" +#else +#define IM_PRId64 "lld" +#define IM_PRIu64 "llu" +#define IM_PRIX64 "llX" +#endif // #if defined(_MSC_VER)&&!defined(__clang__) +//----------------------------------------------------------------------------- +// [SECTION] Generic helpers +// Note that the ImXXX helpers functions are lower-level than ImGui functions. +// ImGui functions or the ImGui context are never called/used from other ImXXX functions. +//----------------------------------------------------------------------------- +// - Helpers: Hashing +// - Helpers: Sorting +// - Helpers: Bit manipulation +// - Helpers: String +// - Helpers: Formatting +// - Helpers: UTF-8 <> wchar conversions +// - Helpers: ImVec2/ImVec4 operators +// - Helpers: Maths +// - Helpers: Geometry +// - Helper: ImVec1 +// - Helper: ImVec2ih +// - Helper: ImRect +// - Helper: ImBitArray +// - Helper: ImBitVector +// - Helper: ImSpan<>, ImSpanAllocator<> +// - Helper: ImStableVector<> +// - Helper: ImPool<> +// - Helper: ImChunkStream<> +// - Helper: ImGuiTextIndex +// - Helper: ImGuiStorage +//----------------------------------------------------------------------------- + +// Helpers: Hashing +CIMGUI_API ImGuiID cImHashData(const void* data, size_t data_size); // Implied seed = 0 +CIMGUI_API ImGuiID cImHashDataEx(const void* data, size_t data_size, ImGuiID seed /* = 0 */); +CIMGUI_API ImGuiID cImHashStr(const char* data); // Implied data_size = 0, seed = 0 +CIMGUI_API ImGuiID cImHashStrEx(const char* data, size_t data_size /* = 0 */, ImGuiID seed /* = 0 */); + +// Helpers: Color Blending +CIMGUI_API ImU32 cImAlphaBlendColors(ImU32 col_a, ImU32 col_b); + +// Helpers: Bit manipulation +CIMGUI_API bool cImIsPowerOfTwo(int v); +CIMGUI_API bool cImIsPowerOfTwoImU64(ImU64 v); +CIMGUI_API int cImUpperPowerOfTwo(int v); +CIMGUI_API unsigned int cImCountSetBits(unsigned int v); + +// Helpers: String +#define ImStrlen strlen +#define ImMemchr memchr +CIMGUI_API int cImStricmp(const char* str1, const char* str2); // Case insensitive compare. +CIMGUI_API int cImStrnicmp(const char* str1, const char* str2, size_t count); // Case insensitive compare to a certain count. +CIMGUI_API void cImStrncpy(char* dst, const char* src, size_t count); // Copy to a certain count and always zero terminate (strncpy doesn't). +CIMGUI_API char* cImStrdup(const char* str); // Duplicate a string. +CIMGUI_API void* cImMemdup(const void* src, size_t size); // Duplicate a chunk of memory. +CIMGUI_API char* cImStrdupcpy(char* dst, size_t* p_dst_size, const char* str); // Copy in provided buffer, recreate buffer if needed. +CIMGUI_API const char* cImStrchrRange(const char* str_begin, const char* str_end, char c); // Find first occurrence of 'c' in string range. +CIMGUI_API const char* cImStreolRange(const char* str, const char* str_end); // End end-of-line +CIMGUI_API const char* cImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end); // Find a substring in a string range. +CIMGUI_API void cImStrTrimBlanks(char* str); // Remove leading and trailing blanks from a buffer. +CIMGUI_API const char* cImStrSkipBlank(const char* str); // Find first non-blank character. +CIMGUI_API int cImStrlenW(const ImWchar* str); // Computer string length (ImWchar string) +CIMGUI_API const char* cImStrbol(const char* buf_mid_line, const char* buf_begin); // Find beginning-of-line +IM_MSVC_RUNTIME_CHECKS_OFF +CIMGUI_API char cImToUpper(char c); +CIMGUI_API bool cImCharIsBlankA(char c); +CIMGUI_API bool cImCharIsBlankW(unsigned int c); +CIMGUI_API bool cImCharIsXdigitA(char c); +IM_MSVC_RUNTIME_CHECKS_RESTORE + +// Helpers: Formatting +CIMGUI_API int cImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3); +CIMGUI_API int cImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3); +CIMGUI_API void cImFormatStringToTempBuffer(const char** out_buf, const char** out_buf_end, const char* fmt, ...) IM_FMTARGS(3); +CIMGUI_API void cImFormatStringToTempBufferV(const char** out_buf, const char** out_buf_end, const char* fmt, va_list args) IM_FMTLIST(3); +CIMGUI_API const char* cImParseFormatFindStart(const char* format); +CIMGUI_API const char* cImParseFormatFindEnd(const char* format); +CIMGUI_API const char* cImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size); +CIMGUI_API void cImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size); +CIMGUI_API const char* cImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size); +CIMGUI_API int cImParseFormatPrecision(const char* format, int default_value); + +// Helpers: UTF-8 <> wchar conversions +CIMGUI_API int cImTextCharToUtf8(char out_buf[5], unsigned int c); // return output UTF-8 bytes count +CIMGUI_API int cImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count +CIMGUI_API int cImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // read one character. return input UTF-8 bytes count +CIMGUI_API int cImTextStrFromUtf8(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end); // Implied in_remaining = NULL +CIMGUI_API int cImTextStrFromUtf8Ex(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end, const char** in_remaining /* = NULL */); // return input UTF-8 bytes count +CIMGUI_API int cImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count) +CIMGUI_API int cImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end); // return number of bytes to express one char in UTF-8 +CIMGUI_API int cImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string in UTF-8 +CIMGUI_API const char* cImTextFindPreviousUtf8Codepoint(const char* in_text_start, const char* in_text_curr); // return previous UTF-8 code-point. +CIMGUI_API int cImTextCountLines(const char* in_text, const char* in_text_end); // return number of lines taken by text. trailing carriage return doesn't count as an extra line. + +// Helpers: File System +#ifdef IMGUI_DISABLE_FILE_FUNCTIONS +#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS +typedef void* ImFileHandle; +CIMGUI_API ImFileHandle cImFileOpen(const char*, const char*); +CIMGUI_API bool cImFileClose(ImFileHandle); +CIMGUI_API ImU64 cImFileGetSize(ImFileHandle); +CIMGUI_API ImU64 cImFileRead(void*, ImU64, ImU64, ImFileHandle); +CIMGUI_API ImU64 cImFileWrite(const void*, ImU64, ImU64, ImFileHandle); +#endif // #ifdef IMGUI_DISABLE_FILE_FUNCTIONS +#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS +typedef FILE* ImFileHandle; +CIMGUI_API ImFileHandle cImFileOpen(const char* filename, const char* mode); +CIMGUI_API bool cImFileClose(ImFileHandle file); +CIMGUI_API ImU64 cImFileGetSize(ImFileHandle file); +CIMGUI_API ImU64 cImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file); +CIMGUI_API ImU64 cImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file); +#else +#define IMGUI_DISABLE_TTY_FUNCTIONS // Can't use stdout, fflush if we are not using default file functions +#endif // #ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS +CIMGUI_API void* cImFileLoadToMemory(const char* filename, const char* mode); // Implied out_file_size = NULL, padding_bytes = 0 +CIMGUI_API void* cImFileLoadToMemoryEx(const char* filename, const char* mode, size_t* out_file_size /* = NULL */, int padding_bytes /* = 0 */); + +// Helpers: Maths +IM_MSVC_RUNTIME_CHECKS_OFF +// - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy) +#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS +#define ImFabs(X) fabsf(X) +#define ImSqrt(X) sqrtf(X) +#define ImFmod(X, Y) fmodf((X), (Y)) +#define ImCos(X) cosf(X) +#define ImSin(X) sinf(X) +#define ImAcos(X) acosf(X) +#define ImAtan2(Y, X) atan2f((Y), (X)) +#define ImAtof(STR) atof(STR) +#define ImCeil(X) ceilf(X) +CIMGUI_API float cImPow(float x, float y); // DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision +CIMGUI_API double cImPowDouble(double x, double y); +CIMGUI_API float cImLog(float x); // DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision +CIMGUI_API double cImLogDouble(double x); +CIMGUI_API int cImAbs(int x); +CIMGUI_API float cImAbsFloat(float x); +CIMGUI_API double cImAbsDouble(double x); +CIMGUI_API float cImSign(float x); // Sign operator - returns -1, 0 or 1 based on sign of argument +CIMGUI_API double cImSignDouble(double x); +#ifdef IMGUI_ENABLE_SSE +CIMGUI_API float cImRsqrt(float x); +#else +CIMGUI_API float cImRsqrtFloat(float x); +#endif // #ifdef IMGUI_ENABLE_SSE +CIMGUI_API double cImRsqrtDouble(double x); +#endif // #ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS +// - Misc maths helpers +CIMGUI_API ImVec2 cImMin(ImVec2 lhs, ImVec2 rhs); +CIMGUI_API ImVec2 cImMax(ImVec2 lhs, ImVec2 rhs); +CIMGUI_API ImVec2 cImClamp(ImVec2 v, ImVec2 mn, ImVec2 mx); +CIMGUI_API ImVec2 cImLerp(ImVec2 a, ImVec2 b, float t); +CIMGUI_API ImVec2 cImLerpImVec2(ImVec2 a, ImVec2 b, ImVec2 t); +CIMGUI_API ImVec4 cImLerpImVec4(ImVec4 a, ImVec4 b, float t); +CIMGUI_API float cImSaturate(float f); +CIMGUI_API float cImLengthSqr(ImVec2 lhs); +CIMGUI_API float cImLengthSqrImVec4(ImVec4 lhs); +CIMGUI_API float cImInvLength(ImVec2 lhs, float fail_value); +CIMGUI_API float cImTrunc(float f); +CIMGUI_API ImVec2 cImTruncImVec2(ImVec2 v); +CIMGUI_API float cImFloor(float f); // Decent replacement for floorf() +CIMGUI_API ImVec2 cImFloorImVec2(ImVec2 v); +CIMGUI_API float cImTrunc64(float f); +CIMGUI_API float cImRound64(float f); +CIMGUI_API int cImModPositive(int a, int b); +CIMGUI_API float cImDot(ImVec2 a, ImVec2 b); +CIMGUI_API ImVec2 cImRotate(ImVec2 v, float cos_a, float sin_a); +CIMGUI_API float cImLinearSweep(float current, float target, float speed); +CIMGUI_API float cImLinearRemapClamp(float s0, float s1, float d0, float d1, float x); +CIMGUI_API ImVec2 cImMul(ImVec2 lhs, ImVec2 rhs); +CIMGUI_API bool cImIsFloatAboveGuaranteedIntegerPrecision(float f); +CIMGUI_API float cImExponentialMovingAverage(float avg, float sample, int n); +IM_MSVC_RUNTIME_CHECKS_RESTORE + +// Helpers: Geometry +CIMGUI_API ImVec2 cImBezierCubicCalc(ImVec2 p1, ImVec2 p2, ImVec2 p3, ImVec2 p4, float t); +CIMGUI_API ImVec2 cImBezierCubicClosestPoint(ImVec2 p1, ImVec2 p2, ImVec2 p3, ImVec2 p4, ImVec2 p, int num_segments); // For curves with explicit number of segments +CIMGUI_API ImVec2 cImBezierCubicClosestPointCasteljau(ImVec2 p1, ImVec2 p2, ImVec2 p3, ImVec2 p4, ImVec2 p, float tess_tol); // For auto-tessellated curves you can use tess_tol = style.CurveTessellationTol +CIMGUI_API ImVec2 cImBezierQuadraticCalc(ImVec2 p1, ImVec2 p2, ImVec2 p3, float t); +CIMGUI_API ImVec2 cImLineClosestPoint(ImVec2 a, ImVec2 b, ImVec2 p); +CIMGUI_API bool cImTriangleContainsPoint(ImVec2 a, ImVec2 b, ImVec2 c, ImVec2 p); +CIMGUI_API ImVec2 cImTriangleClosestPoint(ImVec2 a, ImVec2 b, ImVec2 c, ImVec2 p); +CIMGUI_API void cImTriangleBarycentricCoords(ImVec2 a, ImVec2 b, ImVec2 c, ImVec2 p, float* out_u, float* out_v, float* out_w); +CIMGUI_API float cImTriangleArea(ImVec2 a, ImVec2 b, ImVec2 c); +CIMGUI_API bool cImTriangleIsClockwise(ImVec2 a, ImVec2 b, ImVec2 c); + +// Helper: ImVec1 (1D vector) +// (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches) +IM_MSVC_RUNTIME_CHECKS_OFF +struct ImVec1_t +{ + float x; +}; + +// Helper: ImVec2i (2D vector, integer) +struct ImVec2i_t +{ + int x, y; +}; + +// Helper: ImVec2ih (2D vector, half-size integer, for long-term packed storage) +struct ImVec2ih_t +{ + short x, y; +}; + +// Helper: ImRect (2D axis aligned bounding-box) +// NB: we can't rely on ImVec2 math operators being available here! +struct ImRect_t +{ + ImVec2 Min; // Upper-left + ImVec2 Max; // Lower-right +}; +CIMGUI_API ImVec2 ImRect_GetCenter(const ImRect* self); +CIMGUI_API ImVec2 ImRect_GetSize(const ImRect* self); +CIMGUI_API float ImRect_GetWidth(const ImRect* self); +CIMGUI_API float ImRect_GetHeight(const ImRect* self); +CIMGUI_API float ImRect_GetArea(const ImRect* self); +CIMGUI_API ImVec2 ImRect_GetTL(const ImRect* self); // Top-left +CIMGUI_API ImVec2 ImRect_GetTR(const ImRect* self); // Top-right +CIMGUI_API ImVec2 ImRect_GetBL(const ImRect* self); // Bottom-left +CIMGUI_API ImVec2 ImRect_GetBR(const ImRect* self); // Bottom-right +CIMGUI_API bool ImRect_Contains(const ImRect* self, ImVec2 p); +CIMGUI_API bool ImRect_ContainsImRect(const ImRect* self, ImRect r); +CIMGUI_API bool ImRect_ContainsWithPad(const ImRect* self, ImVec2 p, ImVec2 pad); +CIMGUI_API bool ImRect_Overlaps(const ImRect* self, ImRect r); +CIMGUI_API void ImRect_Add(ImRect* self, ImVec2 p); +CIMGUI_API void ImRect_AddImRect(ImRect* self, ImRect r); +CIMGUI_API void ImRect_Expand(ImRect* self, const float amount); +CIMGUI_API void ImRect_ExpandImVec2(ImRect* self, ImVec2 amount); +CIMGUI_API void ImRect_Translate(ImRect* self, ImVec2 d); +CIMGUI_API void ImRect_TranslateX(ImRect* self, float dx); +CIMGUI_API void ImRect_TranslateY(ImRect* self, float dy); +CIMGUI_API void ImRect_ClipWith(ImRect* self, ImRect r); // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display. +CIMGUI_API void ImRect_ClipWithFull(ImRect* self, ImRect r); // Full version, ensure both points are fully clipped. +CIMGUI_API void ImRect_Floor(ImRect* self); +CIMGUI_API bool ImRect_IsInverted(const ImRect* self); +CIMGUI_API ImVec4 ImRect_ToVec4(const ImRect* self); + +// Helper: ImBitArray +#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! +#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! +CIMGUI_API size_t cImBitArrayGetStorageSizeInBytes(int bitcount); +CIMGUI_API void cImBitArrayClearAllBits(ImU32* arr, int bitcount); +CIMGUI_API bool cImBitArrayTestBit(const ImU32* arr, int n); +CIMGUI_API void cImBitArrayClearBit(ImU32* arr, int n); +CIMGUI_API void cImBitArraySetBit(ImU32* arr, int n); +CIMGUI_API void cImBitArraySetBitRange(ImU32* arr, int n, int n2); // Works on range [n..n2) + +typedef ImU32* ImBitArrayPtr; // Name for use in structs + +// Helper: ImBitVector +// Store 1-bit per value. +struct ImBitVector_t +{ + ImVector_ImU32 Storage; +}; +CIMGUI_API void ImBitVector_Create(ImBitVector* self, int sz); +CIMGUI_API void ImBitVector_Clear(ImBitVector* self); +CIMGUI_API bool ImBitVector_TestBit(const ImBitVector* self, int n); +CIMGUI_API void ImBitVector_SetBit(ImBitVector* self, int n); +CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self, int n); +IM_MSVC_RUNTIME_CHECKS_RESTORE + +// Instantiation of ImSpan +struct ImSpan_ImGuiTableColumn_t +{ + ImGuiTableColumn* Data; + ImGuiTableColumn* DataEnd; +}; +// Instantiation of ImSpan +struct ImSpan_ImGuiTableColumnIdx_t +{ + ImGuiTableColumnIdx* Data; + ImGuiTableColumnIdx* DataEnd; +}; +// Instantiation of ImSpan +struct ImSpan_ImGuiTableCellData_t +{ + ImGuiTableCellData* Data; + ImGuiTableCellData* DataEnd; +}; + +// Instantiation of ImStableVector +struct ImStableVector_ImFontBaked_32_t +{ + int Size /* = 0 */; + int Capacity /* = 0 */; + ImVector_ImFontBakedPtr Blocks; +}; +CIMGUI_API void ImStableVector_ImFontBaked_32_clear(ImStableVector_ImFontBaked_32* self); +CIMGUI_API void ImStableVector_ImFontBaked_32_resize(ImStableVector_ImFontBaked_32* self, int new_size); +CIMGUI_API void ImStableVector_ImFontBaked_32_reserve(ImStableVector_ImFontBaked_32* self, int new_cap); + +// Helper: ImPool<> +// Basic keyed storage for contiguous instances, slow/amortized insertion, O(1) indexable, O(Log N) queries by ID over a dense/hot buffer, +// Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object. +typedef int ImPoolIdx; + +CIMGUI_API void ImGuiTextIndex_clear(ImGuiTextIndex* self); +CIMGUI_API int ImGuiTextIndex_size(ImGuiTextIndex* self); +CIMGUI_API const char* ImGuiTextIndex_get_line_begin(ImGuiTextIndex* self, const char* base, int n); +CIMGUI_API const char* ImGuiTextIndex_get_line_end(ImGuiTextIndex* self, const char* base, int n); +CIMGUI_API void ImGuiTextIndex_append(ImGuiTextIndex* self, const char* base, int old_size, int new_size); + +// Helper: ImGuiStorage +CIMGUI_API ImGuiStoragePair* cImLowerBound(ImGuiStoragePair* in_begin, ImGuiStoragePair* in_end, ImGuiID key); + +//----------------------------------------------------------------------------- +// [SECTION] ImDrawList support +//----------------------------------------------------------------------------- + +// ImDrawList: Helper function to calculate a circle's segment count given its radius and a "maximum error" value. +// Estimation of number of circle segment based on error is derived using method described in https://stackoverflow.com/a/2244088/15194693 +// Number of segments (N) is calculated using equation: +// N = ceil ( pi / acos(1 - error / r) ) where r > 0, error <= r +// Our equation is significantly simpler that one in the post thanks for choosing segment that is +// perpendicular to X axis. Follow steps in the article from this starting condition and you will +// will get this result. +// +// Rendering circles with an odd number of segments, while mathematically correct will produce +// asymmetrical results on the raster grid. Therefore we're rounding N to next even number (7->8, 8->8, 9->10 etc.) +#define IM_ROUNDUP_TO_EVEN(_V) ((((_V) + 1) / 2) * 2) +#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN 4 +#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX 512 +#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) + +// Raw equation from IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC rewritten for 'r' and 'error'. +#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR) ((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI)))) +#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD) ((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD)) + +// ImDrawList: Lookup table size for adaptive arc drawing, cover full circle. +#ifndef IM_DRAWLIST_ARCFAST_TABLE_SIZE +#define IM_DRAWLIST_ARCFAST_TABLE_SIZE 48 // Number of samples in lookup table. +#endif // #ifndef IM_DRAWLIST_ARCFAST_TABLE_SIZE +#define IM_DRAWLIST_ARCFAST_SAMPLE_MAX IM_DRAWLIST_ARCFAST_TABLE_SIZE // Sample index _PathArcToFastEx() for 360 angle. + +// Data shared between all ImDrawList instances +// Conceptually this could have been called e.g. ImDrawListSharedContext +// Typically one ImGui context would create and maintain one of this. +// You may want to create your own instance of you try to ImDrawList completely without ImGui. In that case, watch out for future changes to this structure. +struct ImDrawListSharedData_t +{ + ImVec2 TexUvWhitePixel; // UV of white pixel in the atlas (== FontAtlas->TexUvWhitePixel) + const ImVec4* TexUvLines; // UV of anti-aliased lines in the atlas (== FontAtlas->TexUvLines) + ImFontAtlas* FontAtlas; // Current font atlas + ImFont* Font; // Current font (used for simplified AddText overload) + float FontSize; // Current font size (used for for simplified AddText overload) + float FontScale; // Current font scale (== FontSize / Font->FontSize) + float CurveTessellationTol; // Tessellation tolerance when using PathBezierCurveTo() + float CircleSegmentMaxError; // Number of circle segments to use per pixel of radius for AddCircle() etc + float InitialFringeScale; // Initial scale to apply to AA fringe + ImDrawListFlags InitialFlags; // Initial flags at the beginning of the frame (it is possible to alter flags on a per-drawlist basis afterwards) + ImVec4 ClipRectFullscreen; // Value for PushClipRectFullscreen() + ImVector_ImVec2 TempBuffer; // Temporary write buffer + ImVector_ImDrawListPtr DrawLists; // All draw lists associated to this ImDrawListSharedData + ImGuiContext* Context; // [OPTIONAL] Link to Dear ImGui context. 99% of ImDrawList/ImFontAtlas can function without an ImGui context, but this facilitate handling one legacy edge case. + + // Lookup tables + ImVec2 ArcFastVtx[IM_DRAWLIST_ARCFAST_TABLE_SIZE]; // Sample points on the quarter of the circle. + float ArcFastRadiusCutoff; // Cutoff radius after which arc drawing will fallback to slower PathArcTo() + ImU8 CircleSegmentCounts[64]; // Precomputed segment count for given radius before we calculate it dynamically (to avoid calculation overhead) +}; +CIMGUI_API void ImDrawListSharedData_SetCircleTessellationMaxError(ImDrawListSharedData* self, float max_error); + +struct ImDrawDataBuilder_t +{ + ImVector_ImDrawListPtr* Layers[2]; // Pointers to global layers for: regular, tooltip. LayersP[0] is owned by DrawData. + ImVector_ImDrawListPtr LayerData1; +}; + +struct ImFontStackData_t +{ + ImFont* Font; + float FontSizeBeforeScaling; // ~~ style.FontSizeBase + float FontSizeAfterScaling; // ~~ g.FontSize +}; +struct ImVector_ImFontStackData_t { int Size; int Capacity; ImFontStackData* Data; }; // Instantiation of ImVector + +//----------------------------------------------------------------------------- +// [SECTION] Style support +//----------------------------------------------------------------------------- + +struct ImGuiStyleVarInfo_t +{ + ImU32 Count : 8; // 1+ + ImGuiDataType DataType : 8; + ImU32 Offset : 16; // Offset in parent structure +}; +CIMGUI_API void* ImGuiStyleVarInfo_GetVarPtr(const ImGuiStyleVarInfo* self, void* parent); + +// Stacked color modifier, backup of modified data so we can restore it +struct ImGuiColorMod_t +{ + ImGuiCol Col; + ImVec4 BackupValue; +}; + +// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable. +struct ImGuiStyleMod_t +{ + ImGuiStyleVar VarIdx; + union + { + int BackupInt[2]; + float BackupFloat[2]; + }; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Data types support +//----------------------------------------------------------------------------- + +struct ImGuiDataTypeStorage_t +{ + ImU8 Data[8]; // Opaque storage to fit any data up to ImGuiDataType_COUNT +}; + +// Type information associated to one ImGuiDataType. Retrieve with DataTypeGetInfo(). +struct ImGuiDataTypeInfo_t +{ + size_t Size; // Size in bytes + const char* Name; // Short descriptive name for the type, for debugging + const char* PrintFmt; // Default printf format for the type + const char* ScanFmt; // Default scanf format for the type +}; + +// Extend ImGuiDataType_ +typedef enum +{ + ImGuiDataType_Pointer = ImGuiDataType_COUNT, + ImGuiDataType_ID, +} ImGuiDataTypePrivate_; + +//----------------------------------------------------------------------------- +// [SECTION] Widgets support: flags, enums, data structures +// Instantiation of ImChunkStream +struct ImChunkStream_ImGuiTableSettings_t +{ + ImVector_char Buf; +}; +// Instantiation of ImChunkStream +struct ImChunkStream_ImGuiWindowSettings_t +{ + ImVector_char Buf; +}; +struct ImVector_unsigned_char_t { int Size; int Capacity; unsigned char* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiWindowStackData_t { int Size; int Capacity; ImGuiWindowStackData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiWindowPtr_t { int Size; int Capacity; ImGuiWindow** Data; }; // Instantiation of ImVector +struct ImVector_ImGuiViewportPPtr_t { int Size; int Capacity; ImGuiViewportP** Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTreeNodeStackData_t { int Size; int Capacity; ImGuiTreeNodeStackData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTableTempData_t { int Size; int Capacity; ImGuiTableTempData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTableInstanceData_t { int Size; int Capacity; ImGuiTableInstanceData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTableHeaderData_t { int Size; int Capacity; ImGuiTableHeaderData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTableColumnSortSpecs_t { int Size; int Capacity; ImGuiTableColumnSortSpecs* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTable_t { int Size; int Capacity; ImGuiTable* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTabItem_t { int Size; int Capacity; ImGuiTabItem* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiTabBar_t { int Size; int Capacity; ImGuiTabBar* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiStyleMod_t { int Size; int Capacity; ImGuiStyleMod* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiStackLevelInfo_t { int Size; int Capacity; ImGuiStackLevelInfo* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiShrinkWidthItem_t { int Size; int Capacity; ImGuiShrinkWidthItem* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiSettingsHandler_t { int Size; int Capacity; ImGuiSettingsHandler* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiPtrOrIndex_t { int Size; int Capacity; ImGuiPtrOrIndex* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiPopupData_t { int Size; int Capacity; ImGuiPopupData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiOldColumns_t { int Size; int Capacity; ImGuiOldColumns* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiOldColumnData_t { int Size; int Capacity; ImGuiOldColumnData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiMultiSelectTempData_t { int Size; int Capacity; ImGuiMultiSelectTempData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiMultiSelectState_t { int Size; int Capacity; ImGuiMultiSelectState* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiListClipperRange_t { int Size; int Capacity; ImGuiListClipperRange* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiListClipperData_t { int Size; int Capacity; ImGuiListClipperData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiKeyRoutingData_t { int Size; int Capacity; ImGuiKeyRoutingData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiItemFlags_t { int Size; int Capacity; ImGuiItemFlags* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiInputEvent_t { int Size; int Capacity; ImGuiInputEvent* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiID_t { int Size; int Capacity; ImGuiID* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiGroupData_t { int Size; int Capacity; ImGuiGroupData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiFocusScopeData_t { int Size; int Capacity; ImGuiFocusScopeData* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiDockRequest_t { int Size; int Capacity; ImGuiDockRequest* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiDockNodeSettings_t { int Size; int Capacity; ImGuiDockNodeSettings* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiContextHook_t { int Size; int Capacity; ImGuiContextHook* Data; }; // Instantiation of ImVector +struct ImVector_ImGuiColorMod_t { int Size; int Capacity; ImGuiColorMod* Data; }; // Instantiation of ImVector +struct ImVector_const_charPtr_t { int Size; int Capacity; const char** Data; }; // Instantiation of ImVector +struct ImVector_int_t { int Size; int Capacity; int* Data; }; // Instantiation of ImVector +// Instantiation of ImPool +struct ImPool_ImGuiMultiSelectState_t +{ + ImVector_ImGuiMultiSelectState Buf; // Contiguous data + ImGuiStorage Map; // ID->Index + ImPoolIdx FreeIdx; // Next free idx to use + ImPoolIdx AliveCount; // Number of active/alive items (for display purpose) +}; +// Instantiation of ImPool +struct ImPool_ImGuiTabBar_t +{ + ImVector_ImGuiTabBar Buf; // Contiguous data + ImGuiStorage Map; // ID->Index + ImPoolIdx FreeIdx; // Next free idx to use + ImPoolIdx AliveCount; // Number of active/alive items (for display purpose) +}; +// Instantiation of ImPool +struct ImPool_ImGuiTable_t +{ + ImVector_ImGuiTable Buf; // Contiguous data + ImGuiStorage Map; // ID->Index + ImPoolIdx FreeIdx; // Next free idx to use + ImPoolIdx AliveCount; // Number of active/alive items (for display purpose) +}; +// Helper: ImGuiTextIndex +// Maintain a line index for a text buffer. This is a strong candidate to be moved into the public API. +struct ImGuiTextIndex_t +{ + ImVector_int LineOffsets; + int EndOffset /* = 0 */; // Because we don't own text buffer we need to maintain EndOffset (may bake in LineOffsets?) +}; +typedef struct ImGuiTextIndex_t ImGuiTextIndex; // Maintain a line index for a text buffer. +//----------------------------------------------------------------------------- + +// Extend ImGuiItemFlags +// - input: PushItemFlag() manipulates g.CurrentItemFlags, g.NextItemData.ItemFlags, ItemAdd() calls may add extra flags too. +// - output: stored in g.LastItemData.ItemFlags +typedef enum +{ + // Controlled by user + ImGuiItemFlags_Disabled = 1<<10, // false // Disable interactions (DOES NOT affect visuals. DO NOT mix direct use of this with BeginDisabled(). See BeginDisabled()/EndDisabled() for full disable feature, and github #211). + ImGuiItemFlags_ReadOnly = 1<<11, // false // [ALPHA] Allow hovering interactions but underlying value is not changed. + ImGuiItemFlags_MixedValue = 1<<12, // false // [BETA] Represent a mixed/indeterminate value, generally multi-selection where values differ. Currently only supported by Checkbox() (later should support all sorts of widgets) + ImGuiItemFlags_NoWindowHoverableCheck = 1<<13, // false // Disable hoverable check in ItemHoverable() + ImGuiItemFlags_AllowOverlap = 1<<14, // false // Allow being overlapped by another widget. Not-hovered to Hovered transition deferred by a frame. + ImGuiItemFlags_NoNavDisableMouseHover = 1<<15, // false // Nav keyboard/gamepad mode doesn't disable hover highlight (behave as if NavHighlightItemUnderNav==false). + ImGuiItemFlags_NoMarkEdited = 1<<16, // false // Skip calling MarkItemEdited() + ImGuiItemFlags_NoFocus = 1<<17, // false // [EXPERIMENTAL: Not very well specced] Clicking doesn't take focus. Automatically sets ImGuiButtonFlags_NoFocus + ImGuiButtonFlags_NoNavFocus in ButtonBehavior(). + + // Controlled by widget code + ImGuiItemFlags_Inputable = 1<<20, // false // [WIP] Auto-activate input mode when tab focused. Currently only used and supported by a few items before it becomes a generic feature. + ImGuiItemFlags_HasSelectionUserData = 1<<21, // false // Set by SetNextItemSelectionUserData() + ImGuiItemFlags_IsMultiSelect = 1<<22, // false // Set by SetNextItemSelectionUserData() + + ImGuiItemFlags_Default_ = ImGuiItemFlags_AutoClosePopups, // Please don't change, use PushItemFlag() instead. + + // Obsolete + //ImGuiItemFlags_SelectableDontClosePopup = !ImGuiItemFlags_AutoClosePopups, // Can't have a redirect as we inverted the behavior +} ImGuiItemFlagsPrivate_; + +// Status flags for an already submitted item +// - output: stored in g.LastItemData.StatusFlags +typedef enum +{ + ImGuiItemStatusFlags_None = 0, + ImGuiItemStatusFlags_HoveredRect = 1<<0, // Mouse position is within item rectangle (does NOT mean that the window is in correct z-order and can be hovered!, this is only one part of the most-common IsItemHovered test) + ImGuiItemStatusFlags_HasDisplayRect = 1<<1, // g.LastItemData.DisplayRect is valid + ImGuiItemStatusFlags_Edited = 1<<2, // Value exposed by item was edited in the current frame (should match the bool return value of most widgets) + ImGuiItemStatusFlags_ToggledSelection = 1<<3, // Set when Selectable(), TreeNode() reports toggling a selection. We can't report "Selected", only state changes, in order to easily handle clipping with less issues. + ImGuiItemStatusFlags_ToggledOpen = 1<<4, // Set when TreeNode() reports toggling their open state. + ImGuiItemStatusFlags_HasDeactivated = 1<<5, // Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag. + ImGuiItemStatusFlags_Deactivated = 1<<6, // Only valid if ImGuiItemStatusFlags_HasDeactivated is set. + ImGuiItemStatusFlags_HoveredWindow = 1<<7, // Override the HoveredWindow test to allow cross-window hover testing. + ImGuiItemStatusFlags_Visible = 1<<8, // [WIP] Set when item is overlapping the current clipping rectangle (Used internally. Please don't use yet: API/system will change as we refactor Itemadd()). + ImGuiItemStatusFlags_HasClipRect = 1<<9, // g.LastItemData.ClipRect is valid. + ImGuiItemStatusFlags_HasShortcut = 1<<10, // g.LastItemData.Shortcut valid. Set by SetNextItemShortcut() -> ItemAdd(). + //ImGuiItemStatusFlags_FocusedByTabbing = 1 << 8, // Removed IN 1.90.1 (Dec 2023). The trigger is part of g.NavActivateId. See commit 54c1bdeceb. + + // Additional status + semantic for ImGuiTestEngine +#ifdef IMGUI_ENABLE_TEST_ENGINE + ImGuiItemStatusFlags_Openable = 1<<20, // Item is an openable (e.g. TreeNode) + ImGuiItemStatusFlags_Opened = 1<<21, // Opened status + ImGuiItemStatusFlags_Checkable = 1<<22, // Item is a checkable (e.g. CheckBox, MenuItem) + ImGuiItemStatusFlags_Checked = 1<<23, // Checked status + ImGuiItemStatusFlags_Inputable = 1<<24, // Item is a text-inputable (e.g. InputText, SliderXXX, DragXXX) +#endif // #ifdef IMGUI_ENABLE_TEST_ENGINE +} ImGuiItemStatusFlags_; + +// Extend ImGuiHoveredFlags_ +typedef enum +{ + ImGuiHoveredFlags_DelayMask_ = ImGuiHoveredFlags_DelayNone | ImGuiHoveredFlags_DelayShort | ImGuiHoveredFlags_DelayNormal | ImGuiHoveredFlags_NoSharedDelay, + ImGuiHoveredFlags_AllowedMaskForIsWindowHovered = ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_NoPopupHierarchy | ImGuiHoveredFlags_DockHierarchy | ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary, + ImGuiHoveredFlags_AllowedMaskForIsItemHovered = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayMask_, +} ImGuiHoveredFlagsPrivate_; + +// Extend ImGuiInputTextFlags_ +typedef enum +{ + // [Internal] + ImGuiInputTextFlags_Multiline = 1<<26, // For internal use by InputTextMultiline() + ImGuiInputTextFlags_MergedItem = 1<<27, // For internal use by TempInputText(), will skip calling ItemAdd(). Require bounding-box to strictly match. + ImGuiInputTextFlags_LocalizeDecimalPoint = 1<<28, // For internal use by InputScalar() and TempInputScalar() +} ImGuiInputTextFlagsPrivate_; + +// Extend ImGuiButtonFlags_ +typedef enum +{ + ImGuiButtonFlags_PressedOnClick = 1<<4, // return true on click (mouse down event) + ImGuiButtonFlags_PressedOnClickRelease = 1<<5, // [Default] return true on click + release on same item <-- this is what the majority of Button are using + ImGuiButtonFlags_PressedOnClickReleaseAnywhere = 1<<6, // return true on click + release even if the release event is not done while hovering the item + ImGuiButtonFlags_PressedOnRelease = 1<<7, // return true on release (default requires click+release) + ImGuiButtonFlags_PressedOnDoubleClick = 1<<8, // return true on double-click (default requires click+release) + ImGuiButtonFlags_PressedOnDragDropHold = 1<<9, // return true when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers) + //ImGuiButtonFlags_Repeat = 1 << 10, // hold to repeat -> use ImGuiItemFlags_ButtonRepeat instead. + ImGuiButtonFlags_FlattenChildren = 1<<11, // allow interactions even if a child window is overlapping + ImGuiButtonFlags_AllowOverlap = 1<<12, // require previous frame HoveredId to either match id or be null before being usable. + //ImGuiButtonFlags_DontClosePopups = 1 << 13, // disable automatically closing parent popup on press + //ImGuiButtonFlags_Disabled = 1 << 14, // disable interactions -> use BeginDisabled() or ImGuiItemFlags_Disabled + ImGuiButtonFlags_AlignTextBaseLine = 1<<15, // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine + ImGuiButtonFlags_NoKeyModsAllowed = 1<<16, // disable mouse interaction if a key modifier is held + ImGuiButtonFlags_NoHoldingActiveId = 1<<17, // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only) + ImGuiButtonFlags_NoNavFocus = 1<<18, // don't override navigation focus when activated (FIXME: this is essentially used every time an item uses ImGuiItemFlags_NoNav, but because legacy specs don't requires LastItemData to be set ButtonBehavior(), we can't poll g.LastItemData.ItemFlags) + ImGuiButtonFlags_NoHoveredOnFocus = 1<<19, // don't report as hovered when nav focus is on this item + ImGuiButtonFlags_NoSetKeyOwner = 1<<20, // don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!) + ImGuiButtonFlags_NoTestKeyOwner = 1<<21, // don't test key/input owner when polling the key (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!) + ImGuiButtonFlags_NoFocus = 1<<22, // [EXPERIMENTAL: Not very well specced]. Don't focus parent window when clicking. + ImGuiButtonFlags_PressedOnMask_ = ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_PressedOnDragDropHold, + ImGuiButtonFlags_PressedOnDefault_ = ImGuiButtonFlags_PressedOnClickRelease, + //ImGuiButtonFlags_NoKeyModifiers = ImGuiButtonFlags_NoKeyModsAllowed, // Renamed in 1.91.4 +} ImGuiButtonFlagsPrivate_; + +// Extend ImGuiComboFlags_ +typedef enum +{ + ImGuiComboFlags_CustomPreview = 1<<20, // enable BeginComboPreview() +} ImGuiComboFlagsPrivate_; + +// Extend ImGuiSliderFlags_ +typedef enum +{ + ImGuiSliderFlags_Vertical = 1<<20, // Should this slider be orientated vertically? + ImGuiSliderFlags_ReadOnly = 1<<21, // Consider using g.NextItemData.ItemFlags |= ImGuiItemFlags_ReadOnly instead. +} ImGuiSliderFlagsPrivate_; + +// Extend ImGuiSelectableFlags_ +typedef enum +{ + // NB: need to be in sync with last value of ImGuiSelectableFlags_ + ImGuiSelectableFlags_NoHoldingActiveID = 1<<20, + ImGuiSelectableFlags_SelectOnNav = 1<<21, // (WIP) Auto-select when moved into. This is not exposed in public API as to handle multi-select and modifiers we will need user to explicitly control focus scope. May be replaced with a BeginSelection() API. + ImGuiSelectableFlags_SelectOnClick = 1<<22, // Override button behavior to react on Click (default is Click+Release) + ImGuiSelectableFlags_SelectOnRelease = 1<<23, // Override button behavior to react on Release (default is Click+Release) + ImGuiSelectableFlags_SpanAvailWidth = 1<<24, // Span all avail width even if we declared less for layout purpose. FIXME: We may be able to remove this (added in 6251d379, 2bcafc86 for menus) + ImGuiSelectableFlags_SetNavIdOnHover = 1<<25, // Set Nav/Focus ID on mouse hover (used by MenuItem) + ImGuiSelectableFlags_NoPadWithHalfSpacing = 1<<26, // Disable padding each side with ItemSpacing * 0.5f + ImGuiSelectableFlags_NoSetKeyOwner = 1<<27, // Don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!) +} ImGuiSelectableFlagsPrivate_; + +// Extend ImGuiTreeNodeFlags_ +typedef enum +{ + ImGuiTreeNodeFlags_NoNavFocus = 1<<27, // Don't claim nav focus when interacting with this item (#8551) + ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1<<28, // FIXME-WIP: Hard-coded for CollapsingHeader() + ImGuiTreeNodeFlags_UpsideDownArrow = 1<<29, // FIXME-WIP: Turn Down arrow into an Up arrow, for reversed trees (#6517) + ImGuiTreeNodeFlags_OpenOnMask_ = ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_OpenOnArrow, + ImGuiTreeNodeFlags_DrawLinesMask_ = ImGuiTreeNodeFlags_DrawLinesNone | ImGuiTreeNodeFlags_DrawLinesFull | ImGuiTreeNodeFlags_DrawLinesToNodes, +} ImGuiTreeNodeFlagsPrivate_; + +typedef enum +{ + ImGuiSeparatorFlags_None = 0, + ImGuiSeparatorFlags_Horizontal = 1<<0, // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar + ImGuiSeparatorFlags_Vertical = 1<<1, + ImGuiSeparatorFlags_SpanAllColumns = 1<<2, // Make separator cover all columns of a legacy Columns() set. +} ImGuiSeparatorFlags_; + +// Flags for FocusWindow(). This is not called ImGuiFocusFlags to avoid confusion with public-facing ImGuiFocusedFlags. +// FIXME: Once we finishing replacing more uses of GetTopMostPopupModal()+IsWindowWithinBeginStackOf() +// and FindBlockingModal() with this, we may want to change the flag to be opt-out instead of opt-in. +typedef enum +{ + ImGuiFocusRequestFlags_None = 0, + ImGuiFocusRequestFlags_RestoreFocusedChild = 1<<0, // Find last focused child (if any) and focus it instead. + ImGuiFocusRequestFlags_UnlessBelowModal = 1<<1, // Do not set focus if the window is below a modal. +} ImGuiFocusRequestFlags_; + +typedef enum +{ + ImGuiTextFlags_None = 0, + ImGuiTextFlags_NoWidthForLargeClippedText = 1<<0, +} ImGuiTextFlags_; + +typedef enum +{ + ImGuiTooltipFlags_None = 0, + ImGuiTooltipFlags_OverridePrevious = 1<<1, // Clear/ignore previously submitted tooltip (defaults to append) +} ImGuiTooltipFlags_; + +// FIXME: this is in development, not exposed/functional as a generic feature yet. +// Horizontal/Vertical enums are fixed to 0/1 so they may be used to index ImVec2 +typedef enum +{ + ImGuiLayoutType_Horizontal = 0, + ImGuiLayoutType_Vertical = 1, +} ImGuiLayoutType_; + +// Flags for LogBegin() text capturing function +typedef enum +{ + ImGuiLogFlags_None = 0, + + ImGuiLogFlags_OutputTTY = 1<<0, + ImGuiLogFlags_OutputFile = 1<<1, + ImGuiLogFlags_OutputBuffer = 1<<2, + ImGuiLogFlags_OutputClipboard = 1<<3, + ImGuiLogFlags_OutputMask_ = ImGuiLogFlags_OutputTTY | ImGuiLogFlags_OutputFile | ImGuiLogFlags_OutputBuffer | ImGuiLogFlags_OutputClipboard, +} ImGuiLogFlags_; + +// X/Y enums are fixed to 0/1 so they may be used to index ImVec2 +typedef enum +{ + ImGuiAxis_None = -1, + ImGuiAxis_X = 0, + ImGuiAxis_Y = 1, +} ImGuiAxis; + +typedef enum +{ + ImGuiPlotType_Lines, + ImGuiPlotType_Histogram, +} ImGuiPlotType; + +// Storage data for BeginComboPreview()/EndComboPreview() +struct ImGuiComboPreviewData_t +{ + ImRect PreviewRect; + ImVec2 BackupCursorPos; + ImVec2 BackupCursorMaxPos; + ImVec2 BackupCursorPosPrevLine; + float BackupPrevLineTextBaseOffset; + ImGuiLayoutType BackupLayout; +}; + +// Stacked storage data for BeginGroup()/EndGroup() +struct ImGuiGroupData_t +{ + ImGuiID WindowID; + ImVec2 BackupCursorPos; + ImVec2 BackupCursorMaxPos; + ImVec2 BackupCursorPosPrevLine; + ImVec1 BackupIndent; + ImVec1 BackupGroupOffset; + ImVec2 BackupCurrLineSize; + float BackupCurrLineTextBaseOffset; + ImGuiID BackupActiveIdIsAlive; + bool BackupDeactivatedIdIsAlive; + bool BackupHoveredIdIsAlive; + bool BackupIsSameLine; + bool EmitItem; +}; + +// Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper. +struct ImGuiMenuColumns_t +{ + ImU32 TotalWidth; + ImU32 NextTotalWidth; + ImU16 Spacing; + ImU16 OffsetIcon; // Always zero for now + ImU16 OffsetLabel; // Offsets are locked in Update() + ImU16 OffsetShortcut; + ImU16 OffsetMark; + ImU16 Widths[4]; // Width of: Icon, Label, Shortcut, Mark (accumulators for current frame) +}; +CIMGUI_API void ImGuiMenuColumns_Update(ImGuiMenuColumns* self, float spacing, bool window_reappearing); +CIMGUI_API float ImGuiMenuColumns_DeclColumns(ImGuiMenuColumns* self, float w_icon, float w_label, float w_shortcut, float w_mark); +CIMGUI_API void ImGuiMenuColumns_CalcNextTotalWidth(ImGuiMenuColumns* self, bool update_offsets); + +// Internal temporary state for deactivating InputText() instances. +struct ImGuiInputTextDeactivatedState_t +{ + ImGuiID ID; // widget id owning the text state (which just got deactivated) + ImVector_char TextA; // text buffer +}; +CIMGUI_API void ImGuiInputTextDeactivatedState_ClearFreeMemory(ImGuiInputTextDeactivatedState* self); + +// Forward declare imstb_textedit.h structure + make its main configuration define accessible +#undef IMSTB_TEXTEDIT_STRING +#undef IMSTB_TEXTEDIT_CHARTYPE +#define IMSTB_TEXTEDIT_STRING ImGuiInputTextState +#define IMSTB_TEXTEDIT_CHARTYPE char +#define IMSTB_TEXTEDIT_GETWIDTH_NEWLINE (-1.0f) +#define IMSTB_TEXTEDIT_UNDOSTATECOUNT 99 +#define IMSTB_TEXTEDIT_UNDOCHARCOUNT 999 +typedef struct ImStb_STB_TexteditState_t ImStb_STB_TexteditState; + +// Internal state of the currently focused/edited text input box +// For a given item ID, access with ImGui::GetInputTextState() +struct ImGuiInputTextState_t +{ + ImGuiContext* Ctx; // parent UI context (needs to be set explicitly by parent). + void* Stb; // State for stb_textedit.h + ImGuiInputTextFlags Flags; // copy of InputText() flags. may be used to check if e.g. ImGuiInputTextFlags_Password is set. + ImGuiID ID; // widget id owning the text state + int TextLen; // UTF-8 length of the string in TextA (in bytes) + const char* TextSrc; // == TextA.Data unless read-only, in which case == buf passed to InputText(). Field only set and valid _inside_ the call InputText() call. + ImVector_char TextA; // main UTF8 buffer. TextA.Size is a buffer size! Should always be >= buf_size passed by user (and of course >= CurLenA + 1). + ImVector_char TextToRevertTo; // value to revert to when pressing Escape = backup of end-user buffer at the time of focus (in UTF-8, unaltered) + ImVector_char CallbackTextBackup; // temporary storage for callback to support automatic reconcile of undo-stack + int BufCapacity; // end-user buffer capacity (include zero terminator) + ImVec2 Scroll; // horizontal offset (managed manually) + vertical scrolling (pulled from child window's own Scroll.y) + float CursorAnim; // timer for cursor blink, reset on every user action so the cursor reappears immediately + bool CursorFollow; // set when we want scrolling to follow the current cursor position (not always!) + bool SelectedAllMouseLock; // after a double-click to select all, we ignore further mouse drags to update selection + bool Edited; // edited this frame + bool WantReloadUserBuf; // force a reload of user buf so it may be modified externally. may be automatic in future version. + int ReloadSelectionStart; + int ReloadSelectionEnd; +}; +CIMGUI_API void ImGuiInputTextState_ClearText(ImGuiInputTextState* self); +CIMGUI_API void ImGuiInputTextState_ClearFreeMemory(ImGuiInputTextState* self); +CIMGUI_API void ImGuiInputTextState_OnKeyPressed(ImGuiInputTextState* self, int key); // Cannot be inline because we call in code in stb_textedit.h implementation +CIMGUI_API void ImGuiInputTextState_OnCharPressed(ImGuiInputTextState* self, unsigned int c); +// Cursor & Selection +CIMGUI_API void ImGuiInputTextState_CursorAnimReset(ImGuiInputTextState* self); +CIMGUI_API void ImGuiInputTextState_CursorClamp(ImGuiInputTextState* self); +CIMGUI_API bool ImGuiInputTextState_HasSelection(const ImGuiInputTextState* self); +CIMGUI_API void ImGuiInputTextState_ClearSelection(ImGuiInputTextState* self); +CIMGUI_API int ImGuiInputTextState_GetCursorPos(const ImGuiInputTextState* self); +CIMGUI_API int ImGuiInputTextState_GetSelectionStart(const ImGuiInputTextState* self); +CIMGUI_API int ImGuiInputTextState_GetSelectionEnd(const ImGuiInputTextState* self); +CIMGUI_API void ImGuiInputTextState_SelectAll(ImGuiInputTextState* self); +// Reload user buf (WIP #2890) +// If you modify underlying user-passed const char* while active you need to call this (InputText V2 may lift this) +// strcpy(my_buf, "hello"); +// if (ImGuiInputTextState* state = ImGui::GetInputTextState(id)) // id may be ImGui::GetItemID() is last item +// state->ReloadUserBufAndSelectAll(); +CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndSelectAll(ImGuiInputTextState* self); +CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndKeepSelection(ImGuiInputTextState* self); +CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndMoveToEnd(ImGuiInputTextState* self); + +typedef enum +{ + ImGuiWindowRefreshFlags_None = 0, + ImGuiWindowRefreshFlags_TryToAvoidRefresh = 1<<0, // [EXPERIMENTAL] Try to keep existing contents, USER MUST NOT HONOR BEGIN() RETURNING FALSE AND NOT APPEND. + ImGuiWindowRefreshFlags_RefreshOnHover = 1<<1, // [EXPERIMENTAL] Always refresh on hover + ImGuiWindowRefreshFlags_RefreshOnFocus = 1<<2, // [EXPERIMENTAL] Always refresh on focus + // Refresh policy/frequency, Load Balancing etc. +} ImGuiWindowRefreshFlags_; + +typedef enum +{ + ImGuiNextWindowDataFlags_None = 0, + ImGuiNextWindowDataFlags_HasPos = 1<<0, + ImGuiNextWindowDataFlags_HasSize = 1<<1, + ImGuiNextWindowDataFlags_HasContentSize = 1<<2, + ImGuiNextWindowDataFlags_HasCollapsed = 1<<3, + ImGuiNextWindowDataFlags_HasSizeConstraint = 1<<4, + ImGuiNextWindowDataFlags_HasFocus = 1<<5, + ImGuiNextWindowDataFlags_HasBgAlpha = 1<<6, + ImGuiNextWindowDataFlags_HasScroll = 1<<7, + ImGuiNextWindowDataFlags_HasWindowFlags = 1<<8, + ImGuiNextWindowDataFlags_HasChildFlags = 1<<9, + ImGuiNextWindowDataFlags_HasRefreshPolicy = 1<<10, + ImGuiNextWindowDataFlags_HasViewport = 1<<11, + ImGuiNextWindowDataFlags_HasDock = 1<<12, + ImGuiNextWindowDataFlags_HasWindowClass = 1<<13, +} ImGuiNextWindowDataFlags_; + +// Storage for SetNexWindow** functions +struct ImGuiNextWindowData_t +{ + ImGuiNextWindowDataFlags HasFlags; + + // Members below are NOT cleared. Always rely on HasFlags. + ImGuiCond PosCond; + ImGuiCond SizeCond; + ImGuiCond CollapsedCond; + ImGuiCond DockCond; + ImVec2 PosVal; + ImVec2 PosPivotVal; + ImVec2 SizeVal; + ImVec2 ContentSizeVal; + ImVec2 ScrollVal; + ImGuiWindowFlags WindowFlags; // Only honored by BeginTable() + ImGuiChildFlags ChildFlags; + bool PosUndock; + bool CollapsedVal; + ImRect SizeConstraintRect; + ImGuiSizeCallback SizeCallback; + void* SizeCallbackUserData; + float BgAlphaVal; // Override background alpha + ImGuiID ViewportId; + ImGuiID DockId; + ImGuiWindowClass WindowClass; + ImVec2 MenuBarOffsetMinVal; // (Always on) This is not exposed publicly, so we don't clear it and it doesn't have a corresponding flag (could we? for consistency?) + ImGuiWindowRefreshFlags RefreshFlagsVal; +}; +CIMGUI_API void ImGuiNextWindowData_ClearFlags(ImGuiNextWindowData* self); + +typedef enum +{ + ImGuiNextItemDataFlags_None = 0, + ImGuiNextItemDataFlags_HasWidth = 1<<0, + ImGuiNextItemDataFlags_HasOpen = 1<<1, + ImGuiNextItemDataFlags_HasShortcut = 1<<2, + ImGuiNextItemDataFlags_HasRefVal = 1<<3, + ImGuiNextItemDataFlags_HasStorageID = 1<<4, +} ImGuiNextItemDataFlags_; + +struct ImGuiNextItemData_t +{ + ImGuiNextItemDataFlags HasFlags; // Called HasFlags instead of Flags to avoid mistaking this + ImGuiItemFlags ItemFlags; // Currently only tested/used for ImGuiItemFlags_AllowOverlap and ImGuiItemFlags_HasSelectionUserData. + + // Members below are NOT cleared by ItemAdd() meaning they are still valid during e.g. NavProcessItem(). Always rely on HasFlags. + ImGuiID FocusScopeId; // Set by SetNextItemSelectionUserData() + ImGuiSelectionUserData SelectionUserData; // Set by SetNextItemSelectionUserData() (note that NULL/0 is a valid value, we use -1 == ImGuiSelectionUserData_Invalid to mark invalid values) + float Width; // Set by SetNextItemWidth() + ImGuiKeyChord Shortcut; // Set by SetNextItemShortcut() + ImGuiInputFlags ShortcutFlags; // Set by SetNextItemShortcut() + bool OpenVal; // Set by SetNextItemOpen() + ImU8 OpenCond; // Set by SetNextItemOpen() + ImGuiDataTypeStorage RefVal; // Not exposed yet, for ImGuiInputTextFlags_ParseEmptyAsRefVal + ImGuiID StorageId; // Set by SetNextItemStorageID() +}; +CIMGUI_API void ImGuiNextItemData_ClearFlags(ImGuiNextItemData* self); // Also cleared manually by ItemAdd()! + +// Status storage for the last submitted item +struct ImGuiLastItemData_t +{ + ImGuiID ID; + ImGuiItemFlags ItemFlags; // See ImGuiItemFlags_ (called 'InFlags' before v1.91.4). + ImGuiItemStatusFlags StatusFlags; // See ImGuiItemStatusFlags_ + ImRect Rect; // Full rectangle + ImRect NavRect; // Navigation scoring rectangle (not displayed) + // Rarely used fields are not explicitly cleared, only valid when the corresponding ImGuiItemStatusFlags are set. + ImRect DisplayRect; // Display rectangle. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasDisplayRect) is set. + ImRect ClipRect; // Clip rectangle at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasClipRect) is set.. + ImGuiKeyChord Shortcut; // Shortcut at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasShortcut) is set.. +}; + +// Store data emitted by TreeNode() for usage by TreePop() +// - To implement ImGuiTreeNodeFlags_NavLeftJumpsToParent: store the minimum amount of data +// which we can't infer in TreePop(), to perform the equivalent of NavApplyItemToResult(). +// Only stored when the node is a potential candidate for landing on a Left arrow jump. +struct ImGuiTreeNodeStackData_t +{ + ImGuiID ID; + ImGuiTreeNodeFlags TreeFlags; + ImGuiItemFlags ItemFlags; // Used for nav landing + ImRect NavRect; // Used for nav landing + float DrawLinesX1; + float DrawLinesToNodesY2; + ImGuiTableColumnIdx DrawLinesTableColumn; +}; + +// sizeof() = 20 +struct ImGuiErrorRecoveryState_t +{ + short SizeOfWindowStack; + short SizeOfIDStack; + short SizeOfTreeStack; + short SizeOfColorStack; + short SizeOfStyleVarStack; + short SizeOfFontStack; + short SizeOfFocusScopeStack; + short SizeOfGroupStack; + short SizeOfItemFlagsStack; + short SizeOfBeginPopupStack; + short SizeOfDisabledStack; +}; + +// Data saved for each window pushed into the stack +struct ImGuiWindowStackData_t +{ + ImGuiWindow* Window; + ImGuiLastItemData ParentLastItemDataBackup; + ImGuiErrorRecoveryState StackSizesInBegin; // Store size of various stacks for asserting + bool DisabledOverrideReenable; // Non-child window override disabled flag + float DisabledOverrideReenableAlphaBackup; +}; + +struct ImGuiShrinkWidthItem_t +{ + int Index; + float Width; + float InitialWidth; +}; + +struct ImGuiPtrOrIndex_t +{ + void* Ptr; // Either field can be set, not both. e.g. Dock node tab bars are loose while BeginTabBar() ones are in a pool. + int Index; // Usually index in a main pool. +}; + +// Data used by IsItemDeactivated()/IsItemDeactivatedAfterEdit() functions +struct ImGuiDeactivatedItemData_t +{ + ImGuiID ID; + int ElapseFrame; + bool HasBeenEditedBefore; + bool IsAlive; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Popup support +//----------------------------------------------------------------------------- + +typedef enum +{ + ImGuiPopupPositionPolicy_Default, + ImGuiPopupPositionPolicy_ComboBox, + ImGuiPopupPositionPolicy_Tooltip, +} ImGuiPopupPositionPolicy; + +// Storage for popup stacks (g.OpenPopupStack and g.BeginPopupStack) +struct ImGuiPopupData_t +{ + ImGuiID PopupId; // Set on OpenPopup() + ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup() + ImGuiWindow* RestoreNavWindow; // Set on OpenPopup(), a NavWindow that will be restored on popup close + int ParentNavLayer; // Resolved on BeginPopup(). Actually a ImGuiNavLayer type (declared down below), initialized to -1 which is not part of an enum, but serves well-enough as "not any of layers" value + int OpenFrameCount; // Set on OpenPopup() + ImGuiID OpenParentId; // Set on OpenPopup(), we need this to differentiate multiple menu sets from each others (e.g. inside menu bar vs loose menu items) + ImVec2 OpenPopupPos; // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse) + ImVec2 OpenMousePos; // Set on OpenPopup(), copy of mouse position at the time of opening popup +}; + +//----------------------------------------------------------------------------- +// [SECTION] Inputs support +//----------------------------------------------------------------------------- + +typedef struct ImBitArrayForNamedKeys_t +{ + char __dummy[20]; +} ImBitArrayForNamedKeys; + +// [Internal] Key ranges +#define ImGuiKey_LegacyNativeKey_BEGIN 0 +#define ImGuiKey_LegacyNativeKey_END 512 +#define ImGuiKey_Keyboard_BEGIN (ImGuiKey_NamedKey_BEGIN) +#define ImGuiKey_Keyboard_END (ImGuiKey_GamepadStart) +#define ImGuiKey_Gamepad_BEGIN (ImGuiKey_GamepadStart) +#define ImGuiKey_Gamepad_END (ImGuiKey_GamepadRStickDown + 1) +#define ImGuiKey_Mouse_BEGIN (ImGuiKey_MouseLeft) +#define ImGuiKey_Mouse_END (ImGuiKey_MouseWheelY + 1) +#define ImGuiKey_Aliases_BEGIN (ImGuiKey_Mouse_BEGIN) +#define ImGuiKey_Aliases_END (ImGuiKey_Mouse_END) + +// [Internal] Named shortcuts for Navigation +#define ImGuiKey_NavKeyboardTweakSlow ImGuiMod_Ctrl +#define ImGuiKey_NavKeyboardTweakFast ImGuiMod_Shift +#define ImGuiKey_NavGamepadTweakSlow ImGuiKey_GamepadL1 +#define ImGuiKey_NavGamepadTweakFast ImGuiKey_GamepadR1 +#define ImGuiKey_NavGamepadActivate (g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceRight : ImGuiKey_GamepadFaceDown) +#define ImGuiKey_NavGamepadCancel (g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceDown : ImGuiKey_GamepadFaceRight) +#define ImGuiKey_NavGamepadMenu ImGuiKey_GamepadFaceLeft +#define ImGuiKey_NavGamepadInput ImGuiKey_GamepadFaceUp + +typedef enum +{ + ImGuiInputEventType_None = 0, + ImGuiInputEventType_MousePos, + ImGuiInputEventType_MouseWheel, + ImGuiInputEventType_MouseButton, + ImGuiInputEventType_MouseViewport, + ImGuiInputEventType_Key, + ImGuiInputEventType_Text, + ImGuiInputEventType_Focus, + ImGuiInputEventType_COUNT, +} ImGuiInputEventType; + +typedef enum +{ + ImGuiInputSource_None = 0, + ImGuiInputSource_Mouse, // Note: may be Mouse or TouchScreen or Pen. See io.MouseSource to distinguish them. + ImGuiInputSource_Keyboard, + ImGuiInputSource_Gamepad, + ImGuiInputSource_COUNT, +} ImGuiInputSource; + +// FIXME: Structures in the union below need to be declared as anonymous unions appears to be an extension? +// Using ImVec2() would fail on Clang 'union member 'MousePos' has a non-trivial default constructor' +struct ImGuiInputEventMousePos_t +{ + float PosX, PosY; + ImGuiMouseSource MouseSource; +}; +struct ImGuiInputEventMouseWheel_t +{ + float WheelX, WheelY; + ImGuiMouseSource MouseSource; +}; +struct ImGuiInputEventMouseButton_t +{ + int Button; + bool Down; + ImGuiMouseSource MouseSource; +}; +struct ImGuiInputEventMouseViewport_t +{ + ImGuiID HoveredViewportID; +}; +struct ImGuiInputEventKey_t +{ + ImGuiKey Key; + bool Down; + float AnalogValue; +}; +struct ImGuiInputEventText_t +{ + unsigned int Char; +}; +struct ImGuiInputEventAppFocused_t +{ + bool Focused; +}; + +struct ImGuiInputEvent_t +{ + ImGuiInputEventType Type; + ImGuiInputSource Source; + ImU32 EventId; // Unique, sequential increasing integer to identify an event (if you need to correlate them to other data). + union + { + ImGuiInputEventMousePos MousePos; // if Type == ImGuiInputEventType_MousePos + ImGuiInputEventMouseWheel MouseWheel; // if Type == ImGuiInputEventType_MouseWheel + ImGuiInputEventMouseButton MouseButton; // if Type == ImGuiInputEventType_MouseButton + ImGuiInputEventMouseViewport MouseViewport; // if Type == ImGuiInputEventType_MouseViewport + ImGuiInputEventKey Key; // if Type == ImGuiInputEventType_Key + ImGuiInputEventText Text; // if Type == ImGuiInputEventType_Text + ImGuiInputEventAppFocused AppFocused; // if Type == ImGuiInputEventType_Focus + }; + bool AddedByTestEngine; +}; + +// Input function taking an 'ImGuiID owner_id' argument defaults to (ImGuiKeyOwner_Any == 0) aka don't test ownership, which matches legacy behavior. +#define ImGuiKeyOwner_Any ((ImGuiID)0) // Accept key that have an owner, UNLESS a call to SetKeyOwner() explicitly used ImGuiInputFlags_LockThisFrame or ImGuiInputFlags_LockUntilRelease. +#define ImGuiKeyOwner_NoOwner ((ImGuiID)-1) // Require key to have no owner. +//#define ImGuiKeyOwner_None ImGuiKeyOwner_NoOwner // We previously called this 'ImGuiKeyOwner_None' but it was inconsistent with our pattern that _None values == 0 and quite dangerous. Also using _NoOwner makes the IsKeyPressed() calls more explicit. + +typedef ImS16 ImGuiKeyRoutingIndex; + +// Routing table entry (sizeof() == 16 bytes) +struct ImGuiKeyRoutingData_t +{ + ImGuiKeyRoutingIndex NextEntryIndex; + ImU16 Mods; // Technically we'd only need 4-bits but for simplify we store ImGuiMod_ values which need 16-bits. + ImU8 RoutingCurrScore; // [DEBUG] For debug display + ImU8 RoutingNextScore; // Lower is better (0: perfect score) + ImGuiID RoutingCurr; + ImGuiID RoutingNext; +}; + +// Routing table: maintain a desired owner for each possible key-chord (key + mods), and setup owner in NewFrame() when mods are matching. +// Stored in main context (1 instance) +struct ImGuiKeyRoutingTable_t +{ + ImGuiKeyRoutingIndex Index[ImGuiKey_NamedKey_COUNT]; // Index of first entry in Entries[] + ImVector_ImGuiKeyRoutingData Entries; + ImVector_ImGuiKeyRoutingData EntriesNext; // Double-buffer to avoid reallocation (could use a shared buffer) +}; +CIMGUI_API void ImGuiKeyRoutingTable_Clear(ImGuiKeyRoutingTable* self); + +// This extends ImGuiKeyData but only for named keys (legacy keys don't support the new features) +// Stored in main context (1 per named key). In the future it might be merged into ImGuiKeyData. +struct ImGuiKeyOwnerData_t +{ + ImGuiID OwnerCurr; + ImGuiID OwnerNext; + bool LockThisFrame; // Reading this key requires explicit owner id (until end of frame). Set by ImGuiInputFlags_LockThisFrame. + bool LockUntilRelease; // Reading this key requires explicit owner id (until key is released). Set by ImGuiInputFlags_LockUntilRelease. When this is true LockThisFrame is always true as well. +}; + +// Extend ImGuiInputFlags_ +// Flags for extended versions of IsKeyPressed(), IsMouseClicked(), Shortcut(), SetKeyOwner(), SetItemKeyOwner() +// Don't mistake with ImGuiInputTextFlags! (which is for ImGui::InputText() function) +typedef enum +{ + // Flags for IsKeyPressed(), IsKeyChordPressed(), IsMouseClicked(), Shortcut() + // - Repeat mode: Repeat rate selection + ImGuiInputFlags_RepeatRateDefault = 1<<1, // Repeat rate: Regular (default) + ImGuiInputFlags_RepeatRateNavMove = 1<<2, // Repeat rate: Fast + ImGuiInputFlags_RepeatRateNavTweak = 1<<3, // Repeat rate: Faster + // - Repeat mode: Specify when repeating key pressed can be interrupted. + // - In theory ImGuiInputFlags_RepeatUntilOtherKeyPress may be a desirable default, but it would break too many behavior so everything is opt-in. + ImGuiInputFlags_RepeatUntilRelease = 1<<4, // Stop repeating when released (default for all functions except Shortcut). This only exists to allow overriding Shortcut() default behavior. + ImGuiInputFlags_RepeatUntilKeyModsChange = 1<<5, // Stop repeating when released OR if keyboard mods are changed (default for Shortcut) + ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone = 1<<6, // Stop repeating when released OR if keyboard mods are leaving the None state. Allows going from Mod+Key to Key by releasing Mod. + ImGuiInputFlags_RepeatUntilOtherKeyPress = 1<<7, // Stop repeating when released OR if any other keyboard key is pressed during the repeat + + // Flags for SetKeyOwner(), SetItemKeyOwner() + // - Locking key away from non-input aware code. Locking is useful to make input-owner-aware code steal keys from non-input-owner-aware code. If all code is input-owner-aware locking would never be necessary. + ImGuiInputFlags_LockThisFrame = 1<<20, // Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared at end of frame. + ImGuiInputFlags_LockUntilRelease = 1<<21, // Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared when the key is released or at end of each frame if key is released. + + // - Condition for SetItemKeyOwner() + ImGuiInputFlags_CondHovered = 1<<22, // Only set if item is hovered (default to both) + ImGuiInputFlags_CondActive = 1<<23, // Only set if item is active (default to both) + ImGuiInputFlags_CondDefault_ = ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive, + + // [Internal] Mask of which function support which flags + ImGuiInputFlags_RepeatRateMask_ = ImGuiInputFlags_RepeatRateDefault | ImGuiInputFlags_RepeatRateNavMove | ImGuiInputFlags_RepeatRateNavTweak, + ImGuiInputFlags_RepeatUntilMask_ = ImGuiInputFlags_RepeatUntilRelease | ImGuiInputFlags_RepeatUntilKeyModsChange | ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone | ImGuiInputFlags_RepeatUntilOtherKeyPress, + ImGuiInputFlags_RepeatMask_ = ImGuiInputFlags_Repeat | ImGuiInputFlags_RepeatRateMask_ | ImGuiInputFlags_RepeatUntilMask_, + ImGuiInputFlags_CondMask_ = ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive, + ImGuiInputFlags_RouteTypeMask_ = ImGuiInputFlags_RouteActive | ImGuiInputFlags_RouteFocused | ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteAlways, + ImGuiInputFlags_RouteOptionsMask_ = ImGuiInputFlags_RouteOverFocused | ImGuiInputFlags_RouteOverActive | ImGuiInputFlags_RouteUnlessBgFocused | ImGuiInputFlags_RouteFromRootWindow, + ImGuiInputFlags_SupportedByIsKeyPressed = ImGuiInputFlags_RepeatMask_, + ImGuiInputFlags_SupportedByIsMouseClicked = ImGuiInputFlags_Repeat, + ImGuiInputFlags_SupportedByShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_, + ImGuiInputFlags_SupportedBySetNextItemShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_ | ImGuiInputFlags_Tooltip, + ImGuiInputFlags_SupportedBySetKeyOwner = ImGuiInputFlags_LockThisFrame | ImGuiInputFlags_LockUntilRelease, + ImGuiInputFlags_SupportedBySetItemKeyOwner = ImGuiInputFlags_SupportedBySetKeyOwner | ImGuiInputFlags_CondMask_, +} ImGuiInputFlagsPrivate_; + +//----------------------------------------------------------------------------- +// [SECTION] Clipper support +//----------------------------------------------------------------------------- + +// Note that Max is exclusive, so perhaps should be using a Begin/End convention. +struct ImGuiListClipperRange_t +{ + int Min; + int Max; + bool PosToIndexConvert; // Begin/End are absolute position (will be converted to indices later) + ImS8 PosToIndexOffsetMin; // Add to Min after converting to indices + ImS8 PosToIndexOffsetMax; // Add to Min after converting to indices +}; +CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromIndices(int min, int max); +CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromPositions(float y1, float y2, int off_min, int off_max); + +// Temporary clipper data, buffers shared/reused between instances +struct ImGuiListClipperData_t +{ + ImGuiListClipper* ListClipper; + float LossynessOffset; + int StepNo; + int ItemsFrozen; + ImVector_ImGuiListClipperRange Ranges; +}; +CIMGUI_API void ImGuiListClipperData_Reset(ImGuiListClipperData* self, ImGuiListClipper* clipper); + +//----------------------------------------------------------------------------- +// [SECTION] Navigation support +//----------------------------------------------------------------------------- + +typedef enum +{ + ImGuiActivateFlags_None = 0, + ImGuiActivateFlags_PreferInput = 1<<0, // Favor activation that requires keyboard text input (e.g. for Slider/Drag). Default for Enter key. + ImGuiActivateFlags_PreferTweak = 1<<1, // Favor activation for tweaking with arrows or gamepad (e.g. for Slider/Drag). Default for Space key and if keyboard is not used. + ImGuiActivateFlags_TryToPreserveState = 1<<2, // Request widget to preserve state if it can (e.g. InputText will try to preserve cursor/selection) + ImGuiActivateFlags_FromTabbing = 1<<3, // Activation requested by a tabbing request + ImGuiActivateFlags_FromShortcut = 1<<4, // Activation requested by an item shortcut via SetNextItemShortcut() function. +} ImGuiActivateFlags_; + +// Early work-in-progress API for ScrollToItem() +typedef enum +{ + ImGuiScrollFlags_None = 0, + ImGuiScrollFlags_KeepVisibleEdgeX = 1<<0, // If item is not visible: scroll as little as possible on X axis to bring item back into view [default for X axis] + ImGuiScrollFlags_KeepVisibleEdgeY = 1<<1, // If item is not visible: scroll as little as possible on Y axis to bring item back into view [default for Y axis for windows that are already visible] + ImGuiScrollFlags_KeepVisibleCenterX = 1<<2, // If item is not visible: scroll to make the item centered on X axis [rarely used] + ImGuiScrollFlags_KeepVisibleCenterY = 1<<3, // If item is not visible: scroll to make the item centered on Y axis + ImGuiScrollFlags_AlwaysCenterX = 1<<4, // Always center the result item on X axis [rarely used] + ImGuiScrollFlags_AlwaysCenterY = 1<<5, // Always center the result item on Y axis [default for Y axis for appearing window) + ImGuiScrollFlags_NoScrollParent = 1<<6, // Disable forwarding scrolling to parent window if required to keep item/rect visible (only scroll window the function was applied to). + ImGuiScrollFlags_MaskX_ = ImGuiScrollFlags_KeepVisibleEdgeX | ImGuiScrollFlags_KeepVisibleCenterX | ImGuiScrollFlags_AlwaysCenterX, + ImGuiScrollFlags_MaskY_ = ImGuiScrollFlags_KeepVisibleEdgeY | ImGuiScrollFlags_KeepVisibleCenterY | ImGuiScrollFlags_AlwaysCenterY, +} ImGuiScrollFlags_; + +typedef enum +{ + ImGuiNavRenderCursorFlags_None = 0, + ImGuiNavRenderCursorFlags_Compact = 1<<1, // Compact highlight, no padding/distance from focused item + ImGuiNavRenderCursorFlags_AlwaysDraw = 1<<2, // Draw rectangular highlight if (g.NavId == id) even when g.NavCursorVisible == false, aka even when using the mouse. + ImGuiNavRenderCursorFlags_NoRounding = 1<<3, +#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS + ImGuiNavHighlightFlags_None = ImGuiNavRenderCursorFlags_None, // Renamed in 1.91.4 + ImGuiNavHighlightFlags_Compact = ImGuiNavRenderCursorFlags_Compact, // Renamed in 1.91.4 + ImGuiNavHighlightFlags_AlwaysDraw = ImGuiNavRenderCursorFlags_AlwaysDraw, // Renamed in 1.91.4 + ImGuiNavHighlightFlags_NoRounding = ImGuiNavRenderCursorFlags_NoRounding, // Renamed in 1.91.4 + //ImGuiNavHighlightFlags_TypeThin = ImGuiNavRenderCursorFlags_Compact, // Renamed in 1.90.2 +#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +} ImGuiNavRenderCursorFlags_; + +typedef enum +{ + ImGuiNavMoveFlags_None = 0, + ImGuiNavMoveFlags_LoopX = 1<<0, // On failed request, restart from opposite side + ImGuiNavMoveFlags_LoopY = 1<<1, + ImGuiNavMoveFlags_WrapX = 1<<2, // On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left) + ImGuiNavMoveFlags_WrapY = 1<<3, // This is not super useful but provided for completeness + ImGuiNavMoveFlags_WrapMask_ = ImGuiNavMoveFlags_LoopX | ImGuiNavMoveFlags_LoopY | ImGuiNavMoveFlags_WrapX | ImGuiNavMoveFlags_WrapY, + ImGuiNavMoveFlags_AllowCurrentNavId = 1<<4, // Allow scoring and considering the current NavId as a move target candidate. This is used when the move source is offset (e.g. pressing PageDown actually needs to send a Up move request, if we are pressing PageDown from the bottom-most item we need to stay in place) + ImGuiNavMoveFlags_AlsoScoreVisibleSet = 1<<5, // Store alternate result in NavMoveResultLocalVisible that only comprise elements that are already fully visible (used by PageUp/PageDown) + ImGuiNavMoveFlags_ScrollToEdgeY = 1<<6, // Force scrolling to min/max (used by Home/End) // FIXME-NAV: Aim to remove or reword, probably unnecessary + ImGuiNavMoveFlags_Forwarded = 1<<7, + ImGuiNavMoveFlags_DebugNoResult = 1<<8, // Dummy scoring for debug purpose, don't apply result + ImGuiNavMoveFlags_FocusApi = 1<<9, // Requests from focus API can land/focus/activate items even if they are marked with _NoTabStop (see NavProcessItemForTabbingRequest() for details) + ImGuiNavMoveFlags_IsTabbing = 1<<10, // == Focus + Activate if item is Inputable + DontChangeNavHighlight + ImGuiNavMoveFlags_IsPageMove = 1<<11, // Identify a PageDown/PageUp request. + ImGuiNavMoveFlags_Activate = 1<<12, // Activate/select target item. + ImGuiNavMoveFlags_NoSelect = 1<<13, // Don't trigger selection by not setting g.NavJustMovedTo + ImGuiNavMoveFlags_NoSetNavCursorVisible = 1<<14, // Do not alter the nav cursor visible state + ImGuiNavMoveFlags_NoClearActiveId = 1<<15, // (Experimental) Do not clear active id when applying move result +} ImGuiNavMoveFlags_; + +typedef enum +{ + ImGuiNavLayer_Main = 0, // Main scrolling layer + ImGuiNavLayer_Menu = 1, // Menu layer (access with Alt) + ImGuiNavLayer_COUNT, +} ImGuiNavLayer; + +// Storage for navigation query/results +struct ImGuiNavItemData_t +{ + ImGuiWindow* Window; // Init,Move // Best candidate window (result->ItemWindow->RootWindowForNav == request->Window) + ImGuiID ID; // Init,Move // Best candidate item ID + ImGuiID FocusScopeId; // Init,Move // Best candidate focus scope ID + ImRect RectRel; // Init,Move // Best candidate bounding box in window relative space + ImGuiItemFlags ItemFlags; // ????,Move // Best candidate item flags + float DistBox; // Move // Best candidate box distance to current NavId + float DistCenter; // Move // Best candidate center distance to current NavId + float DistAxial; // Move // Best candidate axial distance to current NavId + ImGuiSelectionUserData SelectionUserData; //I+Mov // Best candidate SetNextItemSelectionUserData() value. Valid if (ItemFlags & ImGuiItemFlags_HasSelectionUserData) +}; +CIMGUI_API void ImGuiNavItemData_Clear(ImGuiNavItemData* self); + +// Storage for PushFocusScope(), g.FocusScopeStack[], g.NavFocusRoute[] +struct ImGuiFocusScopeData_t +{ + ImGuiID ID; + ImGuiID WindowID; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Typing-select support +//----------------------------------------------------------------------------- + +// Flags for GetTypingSelectRequest() +typedef enum +{ + ImGuiTypingSelectFlags_None = 0, + ImGuiTypingSelectFlags_AllowBackspace = 1<<0, // Backspace to delete character inputs. If using: ensure GetTypingSelectRequest() is not called more than once per frame (filter by e.g. focus state) + ImGuiTypingSelectFlags_AllowSingleCharMode = 1<<1, // Allow "single char" search mode which is activated when pressing the same character multiple times. +} ImGuiTypingSelectFlags_; + +// Returned by GetTypingSelectRequest(), designed to eventually be public. +struct ImGuiTypingSelectRequest_t +{ + ImGuiTypingSelectFlags Flags; // Flags passed to GetTypingSelectRequest() + int SearchBufferLen; + const char* SearchBuffer; // Search buffer contents (use full string. unless SingleCharMode is set, in which case use SingleCharSize). + bool SelectRequest; // Set when buffer was modified this frame, requesting a selection. + bool SingleCharMode; // Notify when buffer contains same character repeated, to implement special mode. In this situation it preferred to not display any on-screen search indication. + ImS8 SingleCharSize; // Length in bytes of first letter codepoint (1 for ascii, 2-4 for UTF-8). If (SearchBufferLen==RepeatCharSize) only 1 letter has been input. +}; + +// Storage for GetTypingSelectRequest() +struct ImGuiTypingSelectState_t +{ + ImGuiTypingSelectRequest Request; // User-facing data + char SearchBuffer[64]; // Search buffer: no need to make dynamic as this search is very transient. + ImGuiID FocusScope; + int LastRequestFrame /* = 0 */; + float LastRequestTime /* = 0.0f */; + bool SingleCharModeLock /* = false */; // After a certain single char repeat count we lock into SingleCharMode. Two benefits: 1) buffer never fill, 2) we can provide an immediate SingleChar mode without timer elapsing. +}; +CIMGUI_API void ImGuiTypingSelectState_Clear(ImGuiTypingSelectState* self); // We preserve remaining data for easier debugging + +//----------------------------------------------------------------------------- +// [SECTION] Columns support +//----------------------------------------------------------------------------- + +// Flags for internal's BeginColumns(). This is an obsolete API. Prefer using BeginTable() nowadays! +typedef enum +{ + ImGuiOldColumnFlags_None = 0, + ImGuiOldColumnFlags_NoBorder = 1<<0, // Disable column dividers + ImGuiOldColumnFlags_NoResize = 1<<1, // Disable resizing columns when clicking on the dividers + ImGuiOldColumnFlags_NoPreserveWidths = 1<<2, // Disable column width preservation when adjusting columns + ImGuiOldColumnFlags_NoForceWithinWindow = 1<<3, // Disable forcing columns to fit within window + ImGuiOldColumnFlags_GrowParentContentsSize = 1<<4, // Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove. +} ImGuiOldColumnFlags_; + +struct ImGuiOldColumnData_t +{ + float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right) + float OffsetNormBeforeResize; + ImGuiOldColumnFlags Flags; // Not exposed + ImRect ClipRect; +}; + +struct ImGuiOldColumns_t +{ + ImGuiID ID; + ImGuiOldColumnFlags Flags; + bool IsFirstFrame; + bool IsBeingResized; + int Current; + int Count; + float OffMinX, OffMaxX; // Offsets from HostWorkRect.Min.x + float LineMinY, LineMaxY; + float HostCursorPosY; // Backup of CursorPos at the time of BeginColumns() + float HostCursorMaxPosX; // Backup of CursorMaxPos at the time of BeginColumns() + ImRect HostInitialClipRect; // Backup of ClipRect at the time of BeginColumns() + ImRect HostBackupClipRect; // Backup of ClipRect during PushColumnsBackground()/PopColumnsBackground() + ImRect HostBackupParentWorkRect; //Backup of WorkRect at the time of BeginColumns() + ImVector_ImGuiOldColumnData Columns; + ImDrawListSplitter Splitter; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Box-select support +//----------------------------------------------------------------------------- + +struct ImGuiBoxSelectState_t +{ + // Active box-selection data (persistent, 1 active at a time) + ImGuiID ID; + bool IsActive; + bool IsStarting; + bool IsStartedFromVoid; // Starting click was not from an item. + bool IsStartedSetNavIdOnce; + bool RequestClear; + ImGuiKeyChord KeyMods : 16; // Latched key-mods for box-select logic. + ImVec2 StartPosRel; // Start position in window-contents relative space (to support scrolling) + ImVec2 EndPosRel; // End position in window-contents relative space + ImVec2 ScrollAccum; // Scrolling accumulator (to behave at high-frame spaces) + ImGuiWindow* Window; + + // Temporary/Transient data + bool UnclipMode; // (Temp/Transient, here in hot area). Set/cleared by the BeginMultiSelect()/EndMultiSelect() owning active box-select. + ImRect UnclipRect; // Rectangle where ItemAdd() clipping may be temporarily disabled. Need support by multi-select supporting widgets. + ImRect BoxSelectRectPrev; // Selection rectangle in absolute coordinates (derived every frame from BoxSelectStartPosRel and MousePos) + ImRect BoxSelectRectCurr; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Multi-select support +//----------------------------------------------------------------------------- + +// We always assume that -1 is an invalid value (which works for indices and pointers) +#define ImGuiSelectionUserData_Invalid ((ImGuiSelectionUserData)-1) + +// Temporary storage for multi-select +struct ImGuiMultiSelectTempData_t +{ + ImGuiMultiSelectIO IO; // MUST BE FIRST FIELD. Requests are set and returned by BeginMultiSelect()/EndMultiSelect() + written to by user during the loop. + ImGuiMultiSelectState* Storage; + ImGuiID FocusScopeId; // Copied from g.CurrentFocusScopeId (unless another selection scope was pushed manually) + ImGuiMultiSelectFlags Flags; + ImVec2 ScopeRectMin; + ImVec2 BackupCursorMaxPos; + ImGuiSelectionUserData LastSubmittedItem; // Copy of last submitted item data, used to merge output ranges. + ImGuiID BoxSelectId; + ImGuiKeyChord KeyMods; + ImS8 LoopRequestSetAll; // -1: no operation, 0: clear all, 1: select all. + bool IsEndIO; // Set when switching IO from BeginMultiSelect() to EndMultiSelect() state. + bool IsFocused; // Set if currently focusing the selection scope (any item of the selection). May be used if you have custom shortcut associated to selection. + bool IsKeyboardSetRange; // Set by BeginMultiSelect() when using Shift+Navigation. Because scrolling may be affected we can't afford a frame of lag with Shift+Navigation. + bool NavIdPassedBy; + bool RangeSrcPassedBy; // Set by the item that matches RangeSrcItem. + bool RangeDstPassedBy; // Set by the item that matches NavJustMovedToId when IsSetRange is set. +}; +CIMGUI_API void ImGuiMultiSelectTempData_Clear(ImGuiMultiSelectTempData* self); // Zero-clear except IO as we preserve IO.Requests[] buffer allocation. +CIMGUI_API void ImGuiMultiSelectTempData_ClearIO(ImGuiMultiSelectTempData* self); + +// Persistent storage for multi-select (as long as selection is alive) +struct ImGuiMultiSelectState_t +{ + ImGuiWindow* Window; + ImGuiID ID; + int LastFrameActive; // Last used frame-count, for GC. + int LastSelectionSize; // Set by BeginMultiSelect() based on optional info provided by user. May be -1 if unknown. + ImS8 RangeSelected; // -1 (don't have) or true/false + ImS8 NavIdSelected; // -1 (don't have) or true/false + ImGuiSelectionUserData RangeSrcItem; // + ImGuiSelectionUserData NavIdItem; // SetNextItemSelectionUserData() value for NavId (if part of submitted items) +}; + +//----------------------------------------------------------------------------- +// [SECTION] Docking support +//----------------------------------------------------------------------------- + +#define DOCKING_HOST_DRAW_CHANNEL_BG 0 // Dock host: background fill +#define DOCKING_HOST_DRAW_CHANNEL_FG 1 // Dock host: decorations and contents + +#ifdef IMGUI_HAS_DOCK +// Extend ImGuiDockNodeFlags_ +typedef enum +{ + // [Internal] + ImGuiDockNodeFlags_DockSpace = 1<<10, // Saved // A dockspace is a node that occupy space within an existing user window. Otherwise the node is floating and create its own window. + ImGuiDockNodeFlags_CentralNode = 1<<11, // Saved // The central node has 2 main properties: stay visible when empty, only use "remaining" spaces from its neighbor. + ImGuiDockNodeFlags_NoTabBar = 1<<12, // Saved // Tab bar is completely unavailable. No triangle in the corner to enable it back. + ImGuiDockNodeFlags_HiddenTabBar = 1<<13, // Saved // Tab bar is hidden, with a triangle in the corner to show it again (NB: actual tab-bar instance may be destroyed as this is only used for single-window tab bar) + ImGuiDockNodeFlags_NoWindowMenuButton = 1<<14, // Saved // Disable window/docking menu (that one that appears instead of the collapse button) + ImGuiDockNodeFlags_NoCloseButton = 1<<15, // Saved // Disable close button + ImGuiDockNodeFlags_NoResizeX = 1<<16, // // + ImGuiDockNodeFlags_NoResizeY = 1<<17, // // + ImGuiDockNodeFlags_DockedWindowsInFocusRoute = 1<<18, // // Any docked window will be automatically be focus-route chained (window->ParentWindowForFocusRoute set to this) so Shortcut() in this window can run when any docked window is focused. + + // Disable docking/undocking actions in this dockspace or individual node (existing docked nodes will be preserved) + // Those are not exposed in public because the desirable sharing/inheriting/copy-flag-on-split behaviors are quite difficult to design and understand. + // The two public flags ImGuiDockNodeFlags_NoDockingOverCentralNode/ImGuiDockNodeFlags_NoDockingSplit don't have those issues. + ImGuiDockNodeFlags_NoDockingSplitOther = 1<<19, // // Disable this node from splitting other windows/nodes. + ImGuiDockNodeFlags_NoDockingOverMe = 1<<20, // // Disable other windows/nodes from being docked over this node. + ImGuiDockNodeFlags_NoDockingOverOther = 1<<21, // // Disable this node from being docked over another window or non-empty node. + ImGuiDockNodeFlags_NoDockingOverEmpty = 1<<22, // // Disable this node from being docked over an empty node (e.g. DockSpace with no other windows) + ImGuiDockNodeFlags_NoDocking = ImGuiDockNodeFlags_NoDockingOverMe | ImGuiDockNodeFlags_NoDockingOverOther | ImGuiDockNodeFlags_NoDockingOverEmpty | ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoDockingSplitOther, + + // Masks + ImGuiDockNodeFlags_SharedFlagsInheritMask_ = ~0, + ImGuiDockNodeFlags_NoResizeFlagsMask_ = (int)ImGuiDockNodeFlags_NoResize | ImGuiDockNodeFlags_NoResizeX | ImGuiDockNodeFlags_NoResizeY, + + // When splitting, those local flags are moved to the inheriting child, never duplicated + ImGuiDockNodeFlags_LocalFlagsTransferMask_ = (int)ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoResizeFlagsMask_ |(int)ImGuiDockNodeFlags_AutoHideTabBar | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton, + ImGuiDockNodeFlags_SavedFlagsMask_ = ImGuiDockNodeFlags_NoResizeFlagsMask_ | ImGuiDockNodeFlags_DockSpace | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton, +} ImGuiDockNodeFlagsPrivate_; + +// Store the source authority (dock node vs window) of a field +typedef enum +{ + ImGuiDataAuthority_Auto, + ImGuiDataAuthority_DockNode, + ImGuiDataAuthority_Window, +} ImGuiDataAuthority_; + +typedef enum +{ + ImGuiDockNodeState_Unknown, + ImGuiDockNodeState_HostWindowHiddenBecauseSingleWindow, + ImGuiDockNodeState_HostWindowHiddenBecauseWindowsAreResizing, + ImGuiDockNodeState_HostWindowVisible, +} ImGuiDockNodeState; + +// sizeof() 156~192 +struct ImGuiDockNode_t +{ + ImGuiID ID; + ImGuiDockNodeFlags SharedFlags; // (Write) Flags shared by all nodes of a same dockspace hierarchy (inherited from the root node) + ImGuiDockNodeFlags LocalFlags; // (Write) Flags specific to this node + ImGuiDockNodeFlags LocalFlagsInWindows; // (Write) Flags specific to this node, applied from windows + ImGuiDockNodeFlags MergedFlags; // (Read) Effective flags (== SharedFlags | LocalFlagsInNode | LocalFlagsInWindows) + ImGuiDockNodeState State; + ImGuiDockNode* ParentNode; + ImGuiDockNode* ChildNodes[2]; // [Split node only] Child nodes (left/right or top/bottom). Consider switching to an array. + ImVector_ImGuiWindowPtr Windows; // Note: unordered list! Iterate TabBar->Tabs for user-order. + ImGuiTabBar* TabBar; + ImVec2 Pos; // Current position + ImVec2 Size; // Current size + ImVec2 SizeRef; // [Split node only] Last explicitly written-to size (overridden when using a splitter affecting the node), used to calculate Size. + ImGuiAxis SplitAxis; // [Split node only] Split axis (X or Y) + ImGuiWindowClass WindowClass; // [Root node only] + ImU32 LastBgColor; + + ImGuiWindow* HostWindow; + ImGuiWindow* VisibleWindow; // Generally point to window which is ID is == SelectedTabID, but when CTRL+Tabbing this can be a different window. + ImGuiDockNode* CentralNode; // [Root node only] Pointer to central node. + ImGuiDockNode* OnlyNodeWithWindows; // [Root node only] Set when there is a single visible node within the hierarchy. + int CountNodeWithWindows; // [Root node only] + int LastFrameAlive; // Last frame number the node was updated or kept alive explicitly with DockSpace() + ImGuiDockNodeFlags_KeepAliveOnly + int LastFrameActive; // Last frame number the node was updated. + int LastFrameFocused; // Last frame number the node was focused. + ImGuiID LastFocusedNodeId; // [Root node only] Which of our child docking node (any ancestor in the hierarchy) was last focused. + ImGuiID SelectedTabId; // [Leaf node only] Which of our tab/window is selected. + ImGuiID WantCloseTabId; // [Leaf node only] Set when closing a specific tab/window. + ImGuiID RefViewportId; // Reference viewport ID from visible window when HostWindow == NULL. + ImGuiDataAuthority AuthorityForPos : 3; + ImGuiDataAuthority AuthorityForSize : 3; + ImGuiDataAuthority AuthorityForViewport : 3; + bool IsVisible : 1; // Set to false when the node is hidden (usually disabled as it has no active window) + bool IsFocused : 1; + bool IsBgDrawnThisFrame : 1; + bool HasCloseButton : 1; // Provide space for a close button (if any of the docked window has one). Note that button may be hidden on window without one. + bool HasWindowMenuButton : 1; + bool HasCentralNodeChild : 1; + bool WantCloseAll : 1; // Set when closing all tabs at once. + bool WantLockSizeOnce : 1; + bool WantMouseMove : 1; // After a node extraction we need to transition toward moving the newly created host window + bool WantHiddenTabBarUpdate : 1; + bool WantHiddenTabBarToggle : 1; +}; +CIMGUI_API bool ImGuiDockNode_IsRootNode(const ImGuiDockNode* self); +CIMGUI_API bool ImGuiDockNode_IsDockSpace(const ImGuiDockNode* self); +CIMGUI_API bool ImGuiDockNode_IsFloatingNode(const ImGuiDockNode* self); +CIMGUI_API bool ImGuiDockNode_IsCentralNode(const ImGuiDockNode* self); +CIMGUI_API bool ImGuiDockNode_IsHiddenTabBar(const ImGuiDockNode* self); // Hidden tab bar can be shown back by clicking the small triangle +CIMGUI_API bool ImGuiDockNode_IsNoTabBar(const ImGuiDockNode* self); // Never show a tab bar +CIMGUI_API bool ImGuiDockNode_IsSplitNode(const ImGuiDockNode* self); +CIMGUI_API bool ImGuiDockNode_IsLeafNode(const ImGuiDockNode* self); +CIMGUI_API bool ImGuiDockNode_IsEmpty(const ImGuiDockNode* self); +CIMGUI_API ImRect ImGuiDockNode_Rect(const ImGuiDockNode* self); +CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self, ImGuiDockNodeFlags flags); +CIMGUI_API void ImGuiDockNode_UpdateMergedFlags(ImGuiDockNode* self); + +// List of colors that are stored at the time of Begin() into Docked Windows. +// We currently store the packed colors in a simple array window->DockStyle.Colors[]. +// A better solution may involve appending into a log of colors in ImGuiContext + store offsets into those arrays in ImGuiWindow, +// but it would be more complex as we'd need to double-buffer both as e.g. drop target may refer to window from last frame. +typedef enum +{ + ImGuiWindowDockStyleCol_Text, + ImGuiWindowDockStyleCol_TabHovered, + ImGuiWindowDockStyleCol_TabFocused, + ImGuiWindowDockStyleCol_TabSelected, + ImGuiWindowDockStyleCol_TabSelectedOverline, + ImGuiWindowDockStyleCol_TabDimmed, + ImGuiWindowDockStyleCol_TabDimmedSelected, + ImGuiWindowDockStyleCol_TabDimmedSelectedOverline, + ImGuiWindowDockStyleCol_COUNT, +} ImGuiWindowDockStyleCol; + +// We don't store style.Alpha: dock_node->LastBgColor embeds it and otherwise it would only affect the docking tab, which intuitively I would say we don't want to. +struct ImGuiWindowDockStyle_t +{ + ImU32 Colors[ImGuiWindowDockStyleCol_COUNT]; +}; + +struct ImGuiDockContext_t +{ + ImGuiStorage Nodes; // Map ID -> ImGuiDockNode*: Active nodes + ImVector_ImGuiDockRequest Requests; + ImVector_ImGuiDockNodeSettings NodesSettings; + bool WantFullRebuild; +}; +#endif// #ifdef IMGUI_HAS_DOCK +//----------------------------------------------------------------------------- +// [SECTION] Viewport support +//----------------------------------------------------------------------------- + +// ImGuiViewport Private/Internals fields (cardinal sin: we are using inheritance!) +// Every instance of ImGuiViewport is in fact a ImGuiViewportP. +struct ImGuiViewportP_t +{ + // Appended from parent type ImGuiViewport + ImGuiID ID; // Unique identifier for the viewport + ImGuiViewportFlags Flags; // See ImGuiViewportFlags_ + ImVec2 Pos; // Main Area: Position of the viewport (Dear ImGui coordinates are the same as OS desktop/native coordinates) + ImVec2 Size; // Main Area: Size of the viewport. + ImVec2 FramebufferScale; // Density of the viewport for Retina display (always 1,1 on Windows, may be 2,2 etc on macOS/iOS). This will affect font rasterizer density. + ImVec2 WorkPos; // Work Area: Position of the viewport minus task bars, menus bars, status bars (>= Pos) + ImVec2 WorkSize; // Work Area: Size of the viewport minus task bars, menu bars, status bars (<= Size) + float DpiScale; // 1.0f = 96 DPI = No extra scale. + ImGuiID ParentViewportId; // (Advanced) 0: no parent. Instruct the platform backend to setup a parent/child relationship between platform windows. + ImDrawData* DrawData; // The ImDrawData corresponding to this viewport. Valid after Render() and until the next call to NewFrame(). + // Platform/Backend Dependent Data + // Our design separate the Renderer and Platform backends to facilitate combining default backends with each others. + // When our create your own backend for a custom engine, it is possible that both Renderer and Platform will be handled + // by the same system and you may not need to use all the UserData/Handle fields. + // The library never uses those fields, they are merely storage to facilitate backend implementation. + void* RendererUserData; // void* to hold custom data structure for the renderer (e.g. swap chain, framebuffers etc.). generally set by your Renderer_CreateWindow function. + void* PlatformUserData; // void* to hold custom data structure for the OS / platform (e.g. windowing info, render context). generally set by your Platform_CreateWindow function. + void* PlatformHandle; // void* to hold higher-level, platform window handle (e.g. HWND for Win32 backend, Uint32 WindowID for SDL, GLFWWindow* for GLFW), for FindViewportByPlatformHandle(). + void* PlatformHandleRaw; // void* to hold lower-level, platform-native window handle (always HWND on Win32 platform, unused for other platforms). + bool PlatformWindowCreated; // Platform window has been created (Platform_CreateWindow() has been called). This is false during the first frame where a viewport is being created. + bool PlatformRequestMove; // Platform window requested move (e.g. window was moved by the OS / host window manager, authoritative position will be OS window position) + bool PlatformRequestResize; // Platform window requested resize (e.g. window was resized by the OS / host window manager, authoritative size will be OS window size) + bool PlatformRequestClose; // Platform window requested closure (e.g. window was moved by the OS / host window manager, e.g. pressing ALT-F4) + + ImGuiWindow* Window; // Set when the viewport is owned by a window (and ImGuiViewportFlags_CanHostOtherWindows is NOT set) + int Idx; + int LastFrameActive; // Last frame number this viewport was activated by a window + int LastFocusedStampCount; // Last stamp number from when a window hosted by this viewport was focused (by comparing this value between two viewport we have an implicit viewport z-order we use as fallback) + ImGuiID LastNameHash; + ImVec2 LastPos; + ImVec2 LastSize; + float Alpha; // Window opacity (when dragging dockable windows/viewports we make them transparent) + float LastAlpha; + bool LastFocusedHadNavWindow; // Instead of maintaining a LastFocusedWindow (which may harder to correctly maintain), we merely store weither NavWindow != NULL last time the viewport was focused. + short PlatformMonitor; + int BgFgDrawListsLastFrame[2]; // Last frame number the background (0) and foreground (1) draw lists were used + ImDrawList* BgFgDrawLists[2]; // Convenience background (0) and foreground (1) draw lists. We use them to draw software mouser cursor when io.MouseDrawCursor is set and to draw most debug overlays. + ImDrawData DrawDataP; + ImDrawDataBuilder DrawDataBuilder; // Temporary data while building final ImDrawData + ImVec2 LastPlatformPos; + ImVec2 LastPlatformSize; + ImVec2 LastRendererSize; + + // Per-viewport work area + // - Insets are >= 0.0f values, distance from viewport corners to work area. + // - BeginMainMenuBar() and DockspaceOverViewport() tend to use work area to avoid stepping over existing contents. + // - Generally 'safeAreaInsets' in iOS land, 'DisplayCutout' in Android land. + ImVec2 WorkInsetMin; // Work Area inset locked for the frame. GetWorkRect() always fits within GetMainRect(). + ImVec2 WorkInsetMax; // " + ImVec2 BuildWorkInsetMin; // Work Area inset accumulator for current frame, to become next frame's WorkInset + ImVec2 BuildWorkInsetMax; // " +}; +CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self); +// Calculate work rect pos/size given a set of offset (we have 1 pair of offset for rect locked from last frame data, and 1 pair for currently building rect) +CIMGUI_API ImVec2 ImGuiViewportP_CalcWorkRectPos(const ImGuiViewportP* self, ImVec2 inset_min); +CIMGUI_API ImVec2 ImGuiViewportP_CalcWorkRectSize(const ImGuiViewportP* self, ImVec2 inset_min, ImVec2 inset_max); +CIMGUI_API void ImGuiViewportP_UpdateWorkRect(ImGuiViewportP* self); // Update public fields +// Helpers to retrieve ImRect (we don't need to store BuildWorkRect as every access tend to change it, hence the code asymmetry) +CIMGUI_API ImRect ImGuiViewportP_GetMainRect(const ImGuiViewportP* self); +CIMGUI_API ImRect ImGuiViewportP_GetWorkRect(const ImGuiViewportP* self); +CIMGUI_API ImRect ImGuiViewportP_GetBuildWorkRect(const ImGuiViewportP* self); + +//----------------------------------------------------------------------------- +// [SECTION] Settings support +//----------------------------------------------------------------------------- + +// Windows data saved in imgui.ini file +// Because we never destroy or rename ImGuiWindowSettings, we can store the names in a separate buffer easily. +// (this is designed to be stored in a ImChunkStream buffer, with the variable-length Name following our structure) +struct ImGuiWindowSettings_t +{ + ImGuiID ID; + ImVec2ih Pos; // NB: Settings position are stored RELATIVE to the viewport! Whereas runtime ones are absolute positions. + ImVec2ih Size; + ImVec2ih ViewportPos; + ImGuiID ViewportId; + ImGuiID DockId; // ID of last known DockNode (even if the DockNode is invisible because it has only 1 active window), or 0 if none. + ImGuiID ClassId; // ID of window class if specified + short DockOrder; // Order of the last time the window was visible within its DockNode. This is used to reorder windows that are reappearing on the same frame. Same value between windows that were active and windows that were none are possible. + bool Collapsed; + bool IsChild; + bool WantApply; // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context) + bool WantDelete; // Set to invalidate/delete the settings entry +}; +CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self); + +struct ImGuiSettingsHandler_t +{ + const char* TypeName; // Short description stored in .ini file. Disallowed characters: '[' ']' + ImGuiID TypeHash; // == ImHashStr(TypeName) + void (*ClearAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Clear all settings data + void (*ReadInitFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Read: Called before reading (in registration order) + void* (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name); // Read: Called when entering into a new ini entry e.g. "[Window][Name]" + void (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line); // Read: Called for every line of text within an ini entry + void (*ApplyAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Read: Called after reading (in registration order) + void (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf); // Write: Output every entries into 'out_buf' + void* UserData; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Localization support +//----------------------------------------------------------------------------- + +// This is experimental and not officially supported, it'll probably fall short of features, if/when it does we may backtrack. +enum // Forward declared enum type ImGuiLocKey +{ + ImGuiLocKey_VersionStr, + ImGuiLocKey_TableSizeOne, + ImGuiLocKey_TableSizeAllFit, + ImGuiLocKey_TableSizeAllDefault, + ImGuiLocKey_TableResetOrder, + ImGuiLocKey_WindowingMainMenuBar, + ImGuiLocKey_WindowingPopup, + ImGuiLocKey_WindowingUntitled, + ImGuiLocKey_OpenLink_s, + ImGuiLocKey_CopyLink, + ImGuiLocKey_DockingHideTabBar, + ImGuiLocKey_DockingHoldShiftToDock, + ImGuiLocKey_DockingDragToUndockOrMoveNode, + ImGuiLocKey_COUNT, +}; + +struct ImGuiLocEntry_t +{ + ImGuiLocKey Key; + const char* Text; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Error handling, State recovery support +//----------------------------------------------------------------------------- + +// Macros used by Recoverable Error handling +// - Only dispatch error if _EXPR: evaluate as assert (similar to an assert macro). +// - The message will always be a string literal, in order to increase likelihood of being display by an assert handler. +// - See 'Demo->Configuration->Error Handling' and ImGuiIO definitions for details on error handling. +// - Read https://github.com/ocornut/imgui/wiki/Error-Handling for details on error handling. +#ifndef IM_ASSERT_USER_ERROR +#define IM_ASSERT_USER_ERROR(_EXPR,_MSG) do { if (!(_EXPR) && ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } } while (0) // Recoverable User Error +#endif // #ifndef IM_ASSERT_USER_ERROR +// The error callback is currently not public, as it is expected that only advanced users will rely on it. +typedef void (*ImGuiErrorCallback)(ImGuiContext* ctx, void* user_data, const char* msg); // Function signature for g.ErrorCallback + +//----------------------------------------------------------------------------- +// [SECTION] Metrics, Debug Tools +//----------------------------------------------------------------------------- + +// See IMGUI_DEBUG_LOG() and IMGUI_DEBUG_LOG_XXX() macros. +typedef enum +{ + // Event types + ImGuiDebugLogFlags_None = 0, + ImGuiDebugLogFlags_EventError = 1<<0, // Error submitted by IM_ASSERT_USER_ERROR() + ImGuiDebugLogFlags_EventActiveId = 1<<1, + ImGuiDebugLogFlags_EventFocus = 1<<2, + ImGuiDebugLogFlags_EventPopup = 1<<3, + ImGuiDebugLogFlags_EventNav = 1<<4, + ImGuiDebugLogFlags_EventClipper = 1<<5, + ImGuiDebugLogFlags_EventSelection = 1<<6, + ImGuiDebugLogFlags_EventIO = 1<<7, + ImGuiDebugLogFlags_EventFont = 1<<8, + ImGuiDebugLogFlags_EventInputRouting = 1<<9, + ImGuiDebugLogFlags_EventDocking = 1<<10, + ImGuiDebugLogFlags_EventViewport = 1<<11, + + ImGuiDebugLogFlags_EventMask_ = ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventFont | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport, + ImGuiDebugLogFlags_OutputToTTY = 1<<20, // Also send output to TTY + ImGuiDebugLogFlags_OutputToTestEngine = 1<<21, // Also send output to Test Engine +} ImGuiDebugLogFlags_; + +struct ImGuiDebugAllocEntry_t +{ + int FrameCount; + ImS16 AllocCount; + ImS16 FreeCount; +}; + +struct ImGuiDebugAllocInfo_t +{ + int TotalAllocCount; // Number of call to MemAlloc(). + int TotalFreeCount; + ImS16 LastEntriesIdx; // Current index in buffer + ImGuiDebugAllocEntry LastEntriesBuf[6]; // Track last 6 frames that had allocations +}; + +struct ImGuiMetricsConfig_t +{ + bool ShowDebugLog /* = false */; + bool ShowIDStackTool /* = false */; + bool ShowWindowsRects /* = false */; + bool ShowWindowsBeginOrder /* = false */; + bool ShowTablesRects /* = false */; + bool ShowDrawCmdMesh /* = true */; + bool ShowDrawCmdBoundingBoxes /* = true */; + bool ShowTextEncodingViewer /* = false */; + bool ShowTextureUsedRect /* = false */; + bool ShowDockingNodes /* = false */; + int ShowWindowsRectsType /* = -1 */; + int ShowTablesRectsType /* = -1 */; + int HighlightMonitorIdx /* = -1 */; + ImGuiID HighlightViewportID /* = 0 */; + bool ShowFontPreview /* = true */; +}; + +struct ImGuiStackLevelInfo_t +{ + ImGuiID ID; + ImS8 QueryFrameCount; // >= 1: Query in progress + bool QuerySuccess; // Obtained result from DebugHookIdInfo() + ImGuiDataType DataType : 8; + char Desc[57]; // Arbitrarily sized buffer to hold a result (FIXME: could replace Results[] with a chunk stream?) FIXME: Now that we added CTRL+C this should be fixed. +}; + +// State for ID Stack tool queries +struct ImGuiIDStackTool_t +{ + int LastActiveFrame; + int StackLevel; // -1: query stack and resize Results, >= 0: individual stack level + ImGuiID QueryId; // ID to query details for + ImVector_ImGuiStackLevelInfo Results; + bool CopyToClipboardOnCtrlC; + float CopyToClipboardLastTime; + ImGuiTextBuffer ResultPathBuf; +}; + +//----------------------------------------------------------------------------- +// [SECTION] Generic context hooks +//----------------------------------------------------------------------------- + +typedef void (*ImGuiContextHookCallback)(ImGuiContext* ctx, ImGuiContextHook* hook); +typedef enum +{ + ImGuiContextHookType_NewFramePre, + ImGuiContextHookType_NewFramePost, + ImGuiContextHookType_EndFramePre, + ImGuiContextHookType_EndFramePost, + ImGuiContextHookType_RenderPre, + ImGuiContextHookType_RenderPost, + ImGuiContextHookType_Shutdown, + ImGuiContextHookType_PendingRemoval_, +} ImGuiContextHookType; + +struct ImGuiContextHook_t +{ + ImGuiID HookId; // A unique ID assigned by AddContextHook() + ImGuiContextHookType Type; + ImGuiID Owner; + ImGuiContextHookCallback Callback; + void* UserData; +}; + +//----------------------------------------------------------------------------- +// [SECTION] ImGuiContext (main Dear ImGui context) +//----------------------------------------------------------------------------- + +struct ImGuiContext_t +{ + bool Initialized; + ImGuiIO IO; + ImGuiPlatformIO PlatformIO; + ImGuiStyle Style; + ImGuiConfigFlags ConfigFlagsCurrFrame; // = g.IO.ConfigFlags at the time of NewFrame() + ImGuiConfigFlags ConfigFlagsLastFrame; + ImVector_ImFontAtlasPtr FontAtlases; // List of font atlases used by the context (generally only contains g.IO.Fonts aka the main font atlas) + ImFont* Font; // Currently bound font. (== FontStack.back().Font) + ImFontBaked* FontBaked; // Currently bound font at currently bound size. (== Font->GetFontBaked(FontSize)) + float FontSize; // Currently bound font size == line height (== FontSizeBase + externals scales applied in the UpdateCurrentFontSize() function). + float FontSizeBase; // Font size before scaling == style.FontSizeBase == value passed to PushFont() when specified. + float FontBakedScale; // == FontBaked->Size / FontSize. Scale factor over baked size. Rarely used nowadays, very often == 1.0f. + float FontRasterizerDensity; // Current font density. Used by all calls to GetFontBaked(). + float CurrentDpiScale; // Current window/viewport DpiScale == CurrentViewport->DpiScale + ImDrawListSharedData DrawListSharedData; + double Time; + int FrameCount; + int FrameCountEnded; + int FrameCountPlatformEnded; + int FrameCountRendered; + ImGuiID WithinEndChildID; // Set within EndChild() + bool WithinFrameScope; // Set by NewFrame(), cleared by EndFrame() + bool WithinFrameScopeWithImplicitWindow; // Set by NewFrame(), cleared by EndFrame() when the implicit debug window has been pushed + bool GcCompactAll; // Request full GC + bool TestEngineHookItems; // Will call test engine hooks: ImGuiTestEngineHook_ItemAdd(), ImGuiTestEngineHook_ItemInfo(), ImGuiTestEngineHook_Log() + void* TestEngine; // Test engine user data + char ContextName[16]; // Storage for a context name (to facilitate debugging multi-context setups) + + // Inputs + ImVector_ImGuiInputEvent InputEventsQueue; // Input events which will be trickled/written into IO structure. + ImVector_ImGuiInputEvent InputEventsTrail; // Past input events processed in NewFrame(). This is to allow domain-specific application to access e.g mouse/pen trail. + ImGuiMouseSource InputEventsNextMouseSource; + ImU32 InputEventsNextEventId; + + // Windows state + ImVector_ImGuiWindowPtr Windows; // Windows, sorted in display order, back to front + ImVector_ImGuiWindowPtr WindowsFocusOrder; // Root windows, sorted in focus order, back to front. + ImVector_ImGuiWindowPtr WindowsTempSortBuffer; // Temporary buffer used in EndFrame() to reorder windows so parents are kept before their child + ImVector_ImGuiWindowStackData CurrentWindowStack; + ImGuiStorage WindowsById; // Map window's ImGuiID to ImGuiWindow* + int WindowsActiveCount; // Number of unique windows submitted by frame + float WindowsBorderHoverPadding; // Padding around resizable windows for which hovering on counts as hovering the window == ImMax(style.TouchExtraPadding, style.WindowBorderHoverPadding). This isn't so multi-dpi friendly. + ImGuiID DebugBreakInWindow; // Set to break in Begin() call. + ImGuiWindow* CurrentWindow; // Window being drawn into + ImGuiWindow* HoveredWindow; // Window the mouse is hovering. Will typically catch mouse inputs. + ImGuiWindow* HoveredWindowUnderMovingWindow; // Hovered window ignoring MovingWindow. Only set if MovingWindow is set. + ImGuiWindow* HoveredWindowBeforeClear; // Window the mouse is hovering. Filled even with _NoMouse. This is currently useful for multi-context compositors. + ImGuiWindow* MovingWindow; // Track the window we clicked on (in order to preserve focus). The actual window that is moved is generally MovingWindow->RootWindowDockTree. + ImGuiWindow* WheelingWindow; // Track the window we started mouse-wheeling on. Until a timer elapse or mouse has moved, generally keep scrolling the same window even if during the course of scrolling the mouse ends up hovering a child window. + ImVec2 WheelingWindowRefMousePos; + int WheelingWindowStartFrame; // This may be set one frame before WheelingWindow is != NULL + int WheelingWindowScrolledFrame; + float WheelingWindowReleaseTimer; + ImVec2 WheelingWindowWheelRemainder; + ImVec2 WheelingAxisAvg; + + // Item/widgets state and tracking information + ImGuiID DebugDrawIdConflictsId; // Set when we detect multiple items with the same identifier + ImGuiID DebugHookIdInfo; // Will call core hooks: DebugHookIdInfo() from GetID functions, used by ID Stack Tool [next HoveredId/ActiveId to not pull in an extra cache-line] + ImGuiID HoveredId; // Hovered widget, filled during the frame + ImGuiID HoveredIdPreviousFrame; + int HoveredIdPreviousFrameItemCount; // Count numbers of items using the same ID as last frame's hovered id + float HoveredIdTimer; // Measure contiguous hovering time + float HoveredIdNotActiveTimer; // Measure contiguous hovering time where the item has not been active + bool HoveredIdAllowOverlap; + bool HoveredIdIsDisabled; // At least one widget passed the rect test, but has been discarded by disabled flag or popup inhibit. May be true even if HoveredId == 0. + bool ItemUnclipByLog; // Disable ItemAdd() clipping, essentially a memory-locality friendly copy of LogEnabled + ImGuiID ActiveId; // Active widget + ImGuiID ActiveIdIsAlive; // Active widget has been seen this frame (we can't use a bool as the ActiveId may change within the frame) + float ActiveIdTimer; + bool ActiveIdIsJustActivated; // Set at the time of activation for one frame + bool ActiveIdAllowOverlap; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always) + bool ActiveIdNoClearOnFocusLoss; // Disable losing active id if the active id window gets unfocused. + bool ActiveIdHasBeenPressedBefore; // Track whether the active id led to a press (this is to allow changing between PressOnClick and PressOnRelease without pressing twice). Used by range_select branch. + bool ActiveIdHasBeenEditedBefore; // Was the value associated to the widget Edited over the course of the Active state. + bool ActiveIdHasBeenEditedThisFrame; + bool ActiveIdFromShortcut; + ImGuiID ActiveIdDisabledId; // When clicking a disabled item we set ActiveId=window->MoveId to avoid interference with widget code. Actual item ID is stored here. + int ActiveIdMouseButton : 8; + ImVec2 ActiveIdClickOffset; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior) + ImGuiWindow* ActiveIdWindow; + ImGuiInputSource ActiveIdSource; // Activating source: ImGuiInputSource_Mouse OR ImGuiInputSource_Keyboard OR ImGuiInputSource_Gamepad + ImGuiID ActiveIdPreviousFrame; + ImGuiDeactivatedItemData DeactivatedItemData; + ImGuiDataTypeStorage ActiveIdValueOnActivation; // Backup of initial value at the time of activation. ONLY SET BY SPECIFIC WIDGETS: DragXXX and SliderXXX. + ImGuiID LastActiveId; // Store the last non-zero ActiveId, useful for animation. + float LastActiveIdTimer; // Store the last non-zero ActiveId timer since the beginning of activation, useful for animation. + + // Key/Input Ownership + Shortcut Routing system + // - The idea is that instead of "eating" a given key, we can link to an owner. + // - Input query can then read input by specifying ImGuiKeyOwner_Any (== 0), ImGuiKeyOwner_NoOwner (== -1) or a custom ID. + // - Routing is requested ahead of time for a given chord (Key + Mods) and granted in NewFrame(). + double LastKeyModsChangeTime; // Record the last time key mods changed (affect repeat delay when using shortcut logic) + double LastKeyModsChangeFromNoneTime; // Record the last time key mods changed away from being 0 (affect repeat delay when using shortcut logic) + double LastKeyboardKeyPressTime; // Record the last time a keyboard key (ignore mouse/gamepad ones) was pressed. + ImBitArrayForNamedKeys KeysMayBeCharInput; // Lookup to tell if a key can emit char input, see IsKeyChordPotentiallyCharInput(). sizeof() = 20 bytes + ImGuiKeyOwnerData KeysOwnerData[ImGuiKey_NamedKey_COUNT]; + ImGuiKeyRoutingTable KeysRoutingTable; + ImU32 ActiveIdUsingNavDirMask; // Active widget will want to read those nav move requests (e.g. can activate a button and move away from it) + bool ActiveIdUsingAllKeyboardKeys; // Active widget will want to read all keyboard keys inputs. (this is a shortcut for not taking ownership of 100+ keys, frequently used by drag operations) + ImGuiKeyChord DebugBreakInShortcutRouting; // Set to break in SetShortcutRouting()/Shortcut() calls. + //ImU32 ActiveIdUsingNavInputMask; // [OBSOLETE] Since (IMGUI_VERSION_NUM >= 18804) : 'g.ActiveIdUsingNavInputMask |= (1 << ImGuiNavInput_Cancel);' becomes --> 'SetKeyOwner(ImGuiKey_Escape, g.ActiveId) and/or SetKeyOwner(ImGuiKey_NavGamepadCancel, g.ActiveId);' + + // Next window/item data + ImGuiID CurrentFocusScopeId; // Value for currently appending items == g.FocusScopeStack.back(). Not to be mistaken with g.NavFocusScopeId. + ImGuiItemFlags CurrentItemFlags; // Value for currently appending items == g.ItemFlagsStack.back() + ImGuiID DebugLocateId; // Storage for DebugLocateItemOnHover() feature: this is read by ItemAdd() so we keep it in a hot/cached location + ImGuiNextItemData NextItemData; // Storage for SetNextItem** functions + ImGuiLastItemData LastItemData; // Storage for last submitted item (setup by ItemAdd) + ImGuiNextWindowData NextWindowData; // Storage for SetNextWindow** functions + bool DebugShowGroupRects; + + // Shared stacks + ImGuiCol DebugFlashStyleColorIdx; // (Keep close to ColorStack to share cache line) + ImVector_ImGuiColorMod ColorStack; // Stack for PushStyleColor()/PopStyleColor() - inherited by Begin() + ImVector_ImGuiStyleMod StyleVarStack; // Stack for PushStyleVar()/PopStyleVar() - inherited by Begin() + ImVector_ImFontStackData FontStack; // Stack for PushFont()/PopFont() - inherited by Begin() + ImVector_ImGuiFocusScopeData FocusScopeStack; // Stack for PushFocusScope()/PopFocusScope() - inherited by BeginChild(), pushed into by Begin() + ImVector_ImGuiItemFlags ItemFlagsStack; // Stack for PushItemFlag()/PopItemFlag() - inherited by Begin() + ImVector_ImGuiGroupData GroupStack; // Stack for BeginGroup()/EndGroup() - not inherited by Begin() + ImVector_ImGuiPopupData OpenPopupStack; // Which popups are open (persistent) + ImVector_ImGuiPopupData BeginPopupStack; // Which level of BeginPopup() we are in (reset every frame) + ImVector_ImGuiTreeNodeStackData TreeNodeStack; // Stack for TreeNode() + + // Viewports + ImVector_ImGuiViewportPPtr Viewports; // Active viewports (always 1+, and generally 1 unless multi-viewports are enabled). Each viewports hold their copy of ImDrawData. + ImGuiViewportP* CurrentViewport; // We track changes of viewport (happening in Begin) so we can call Platform_OnChangedViewport() + ImGuiViewportP* MouseViewport; + ImGuiViewportP* MouseLastHoveredViewport; // Last known viewport that was hovered by mouse (even if we are not hovering any viewport any more) + honoring the _NoInputs flag. + ImGuiID PlatformLastFocusedViewportId; + ImGuiPlatformMonitor FallbackMonitor; // Virtual monitor used as fallback if backend doesn't provide monitor information. + ImRect PlatformMonitorsFullWorkRect; // Bounding box of all platform monitors + int ViewportCreatedCount; // Unique sequential creation counter (mostly for testing/debugging) + int PlatformWindowsCreatedCount; // Unique sequential creation counter (mostly for testing/debugging) + int ViewportFocusedStampCount; // Every time the front-most window changes, we stamp its viewport with an incrementing counter + + // Keyboard/Gamepad Navigation + bool NavCursorVisible; // Nav focus cursor/rectangle is visible? We hide it after a mouse click. We show it after a nav move. + bool NavHighlightItemUnderNav; // Disable mouse hovering highlight. Highlight navigation focused item instead of mouse hovered item. + //bool NavDisableHighlight; // Old name for !g.NavCursorVisible before 1.91.4 (2024/10/18). OPPOSITE VALUE (g.NavDisableHighlight == !g.NavCursorVisible) + //bool NavDisableMouseHover; // Old name for g.NavHighlightItemUnderNav before 1.91.1 (2024/10/18) this was called When user starts using keyboard/gamepad, we hide mouse hovering highlight until mouse is touched again. + bool NavMousePosDirty; // When set we will update mouse position if io.ConfigNavMoveSetMousePos is set (not enabled by default) + bool NavIdIsAlive; // Nav widget has been seen this frame ~~ NavRectRel is valid + ImGuiID NavId; // Focused item for navigation + ImGuiWindow* NavWindow; // Focused window for navigation. Could be called 'FocusedWindow' + ImGuiID NavFocusScopeId; // Focused focus scope (e.g. selection code often wants to "clear other items" when landing on an item of the same scope) + ImGuiNavLayer NavLayer; // Focused layer (main scrolling layer, or menu/title bar layer) + ImGuiID NavActivateId; // ~~ (g.ActiveId == 0) && (IsKeyPressed(ImGuiKey_Space) || IsKeyDown(ImGuiKey_Enter) || IsKeyPressed(ImGuiKey_NavGamepadActivate)) ? NavId : 0, also set when calling ActivateItemByID() + ImGuiID NavActivateDownId; // ~~ IsKeyDown(ImGuiKey_Space) || IsKeyDown(ImGuiKey_Enter) || IsKeyDown(ImGuiKey_NavGamepadActivate) ? NavId : 0 + ImGuiID NavActivatePressedId; // ~~ IsKeyPressed(ImGuiKey_Space) || IsKeyPressed(ImGuiKey_Enter) || IsKeyPressed(ImGuiKey_NavGamepadActivate) ? NavId : 0 (no repeat) + ImGuiActivateFlags NavActivateFlags; + ImVector_ImGuiFocusScopeData NavFocusRoute; // Reversed copy focus scope stack for NavId (should contains NavFocusScopeId). This essentially follow the window->ParentWindowForFocusRoute chain. + ImGuiID NavHighlightActivatedId; + float NavHighlightActivatedTimer; + ImGuiID NavNextActivateId; // Set by ActivateItemByID(), queued until next frame. + ImGuiActivateFlags NavNextActivateFlags; + ImGuiInputSource NavInputSource; // Keyboard or Gamepad mode? THIS CAN ONLY BE ImGuiInputSource_Keyboard or ImGuiInputSource_Mouse + ImGuiSelectionUserData NavLastValidSelectionUserData; // Last valid data passed to SetNextItemSelectionUser(), or -1. For current window. Not reset when focusing an item that doesn't have selection data. + ImS8 NavCursorHideFrames; + //ImGuiID NavActivateInputId; // Removed in 1.89.4 (July 2023). This is now part of g.NavActivateId and sets g.NavActivateFlags |= ImGuiActivateFlags_PreferInput. See commit c9a53aa74, issue #5606. + + // Navigation: Init & Move Requests + bool NavAnyRequest; // ~~ NavMoveRequest || NavInitRequest this is to perform early out in ItemAdd() + bool NavInitRequest; // Init request for appearing window to select first item + bool NavInitRequestFromMove; + ImGuiNavItemData NavInitResult; // Init request result (first item of the window, or one for which SetItemDefaultFocus() was called) + bool NavMoveSubmitted; // Move request submitted, will process result on next NewFrame() + bool NavMoveScoringItems; // Move request submitted, still scoring incoming items + bool NavMoveForwardToNextFrame; + ImGuiNavMoveFlags NavMoveFlags; + ImGuiScrollFlags NavMoveScrollFlags; + ImGuiKeyChord NavMoveKeyMods; + ImGuiDir NavMoveDir; // Direction of the move request (left/right/up/down) + ImGuiDir NavMoveDirForDebug; + ImGuiDir NavMoveClipDir; // FIXME-NAV: Describe the purpose of this better. Might want to rename? + ImRect NavScoringRect; // Rectangle used for scoring, in screen space. Based of window->NavRectRel[], modified for directional navigation scoring. + ImRect NavScoringNoClipRect; // Some nav operations (such as PageUp/PageDown) enforce a region which clipper will attempt to always keep submitted + int NavScoringDebugCount; // Metrics for debugging + int NavTabbingDir; // Generally -1 or +1, 0 when tabbing without a nav id + int NavTabbingCounter; // >0 when counting items for tabbing + ImGuiNavItemData NavMoveResultLocal; // Best move request candidate within NavWindow + ImGuiNavItemData NavMoveResultLocalVisible; // Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag) + ImGuiNavItemData NavMoveResultOther; // Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag) + ImGuiNavItemData NavTabbingResultFirst; // First tabbing request candidate within NavWindow and flattened hierarchy + + // Navigation: record of last move request + ImGuiID NavJustMovedFromFocusScopeId; // Just navigated from this focus scope id (result of a successfully MoveRequest). + ImGuiID NavJustMovedToId; // Just navigated to this id (result of a successfully MoveRequest). + ImGuiID NavJustMovedToFocusScopeId; // Just navigated to this focus scope id (result of a successfully MoveRequest). + ImGuiKeyChord NavJustMovedToKeyMods; + bool NavJustMovedToIsTabbing; // Copy of ImGuiNavMoveFlags_IsTabbing. Maybe we should store whole flags. + bool NavJustMovedToHasSelectionData; // Copy of move result's ItemFlags & ImGuiItemFlags_HasSelectionUserData). Maybe we should just store ImGuiNavItemData. + + // Navigation: Windowing (CTRL+TAB for list, or Menu button + keys or directional pads to move/resize) + bool ConfigNavWindowingWithGamepad; // = true. Enable CTRL+TAB by holding ImGuiKey_GamepadFaceLeft (== ImGuiKey_NavGamepadMenu). When false, the button may still be used to toggle Menu layer. + ImGuiKeyChord ConfigNavWindowingKeyNext; // = ImGuiMod_Ctrl | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiKey_Tab on OS X). For reconfiguration (see #4828) + ImGuiKeyChord ConfigNavWindowingKeyPrev; // = ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiMod_Shift | ImGuiKey_Tab on OS X) + ImGuiWindow* NavWindowingTarget; // Target window when doing CTRL+Tab (or Pad Menu + FocusPrev/Next), this window is temporarily displayed top-most! + ImGuiWindow* NavWindowingTargetAnim; // Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f, so the fade-out can stay on it. + ImGuiWindow* NavWindowingListWindow; // Internal window actually listing the CTRL+Tab contents + float NavWindowingTimer; + float NavWindowingHighlightAlpha; + ImGuiInputSource NavWindowingInputSource; + bool NavWindowingToggleLayer; // Set while Alt or GamepadMenu is held, may be cleared by other operations, and processed when releasing the key. + ImGuiKey NavWindowingToggleKey; // Keyboard/gamepad key used when toggling to menu layer. + ImVec2 NavWindowingAccumDeltaPos; + ImVec2 NavWindowingAccumDeltaSize; + + // Render + float DimBgRatio; // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list) + + // Drag and Drop + bool DragDropActive; + bool DragDropWithinSource; // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag source. + bool DragDropWithinTarget; // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag target. + ImGuiDragDropFlags DragDropSourceFlags; + int DragDropSourceFrameCount; + int DragDropMouseButton; + ImGuiPayload DragDropPayload; + ImRect DragDropTargetRect; // Store rectangle of current target candidate (we favor small targets when overlapping) + ImRect DragDropTargetClipRect; // Store ClipRect at the time of item's drawing + ImGuiID DragDropTargetId; + ImGuiDragDropFlags DragDropAcceptFlags; + float DragDropAcceptIdCurrRectSurface; // Target item surface (we resolve overlapping targets by prioritizing the smaller surface) + ImGuiID DragDropAcceptIdCurr; // Target item id (set at the time of accepting the payload) + ImGuiID DragDropAcceptIdPrev; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets) + int DragDropAcceptFrameCount; // Last time a target expressed a desire to accept the source + ImGuiID DragDropHoldJustPressedId; // Set when holding a payload just made ButtonBehavior() return a press. + ImVector_unsigned_char DragDropPayloadBufHeap; // We don't expose the ImVector<> directly, ImGuiPayload only holds pointer+size + unsigned char DragDropPayloadBufLocal[16]; // Local buffer for small payloads + + // Clipper + int ClipperTempDataStacked; + ImVector_ImGuiListClipperData ClipperTempData; + + // Tables + ImGuiTable* CurrentTable; + ImGuiID DebugBreakInTable; // Set to break in BeginTable() call. + int TablesTempDataStacked; // Temporary table data size (because we leave previous instances undestructed, we generally don't use TablesTempData.Size) + ImVector_ImGuiTableTempData TablesTempData; // Temporary table data (buffers reused/shared across instances, support nesting) + ImPool_ImGuiTable Tables; // Persistent table data + ImVector_float TablesLastTimeActive; // Last used timestamp of each tables (SOA, for efficient GC) + ImVector_ImDrawChannel DrawChannelsTempMergeBuffer; + + // Tab bars + ImGuiTabBar* CurrentTabBar; + ImPool_ImGuiTabBar TabBars; + ImVector_ImGuiPtrOrIndex CurrentTabBarStack; + ImVector_ImGuiShrinkWidthItem ShrinkWidthBuffer; + + // Multi-Select state + ImGuiBoxSelectState BoxSelectState; + ImGuiMultiSelectTempData* CurrentMultiSelect; + int MultiSelectTempDataStacked; // Temporary multi-select data size (because we leave previous instances undestructed, we generally don't use MultiSelectTempData.Size) + ImVector_ImGuiMultiSelectTempData MultiSelectTempData; + ImPool_ImGuiMultiSelectState MultiSelectStorage; + + // Hover Delay system + ImGuiID HoverItemDelayId; + ImGuiID HoverItemDelayIdPreviousFrame; + float HoverItemDelayTimer; // Currently used by IsItemHovered() + float HoverItemDelayClearTimer; // Currently used by IsItemHovered(): grace time before g.TooltipHoverTimer gets cleared. + ImGuiID HoverItemUnlockedStationaryId; // Mouse has once been stationary on this item. Only reset after departing the item. + ImGuiID HoverWindowUnlockedStationaryId; // Mouse has once been stationary on this window. Only reset after departing the window. + + // Mouse state + ImGuiMouseCursor MouseCursor; + float MouseStationaryTimer; // Time the mouse has been stationary (with some loose heuristic) + ImVec2 MouseLastValidPos; + + // Widget state + ImGuiInputTextState InputTextState; + ImGuiInputTextDeactivatedState InputTextDeactivatedState; + ImFontBaked InputTextPasswordFontBackupBaked; + ImFontFlags InputTextPasswordFontBackupFlags; + ImGuiID TempInputId; // Temporary text input when CTRL+clicking on a slider, etc. + ImGuiDataTypeStorage DataTypeZeroValue; // 0 for all data types + int BeginMenuDepth; + int BeginComboDepth; + ImGuiColorEditFlags ColorEditOptions; // Store user options for color edit widgets + ImGuiID ColorEditCurrentID; // Set temporarily while inside of the parent-most ColorEdit4/ColorPicker4 (because they call each others). + ImGuiID ColorEditSavedID; // ID we are saving/restoring HS for + float ColorEditSavedHue; // Backup of last Hue associated to LastColor, so we can restore Hue in lossy RGB<>HSV round trips + float ColorEditSavedSat; // Backup of last Saturation associated to LastColor, so we can restore Saturation in lossy RGB<>HSV round trips + ImU32 ColorEditSavedColor; // RGB value with alpha set to 0. + ImVec4 ColorPickerRef; // Initial/reference color at the time of opening the color picker. + ImGuiComboPreviewData ComboPreviewData; + ImRect WindowResizeBorderExpectedRect; // Expected border rect, switch to relative edit if moving + bool WindowResizeRelativeMode; + short ScrollbarSeekMode; // 0: scroll to clicked location, -1/+1: prev/next page. + float ScrollbarClickDeltaToGrabCenter; // When scrolling to mouse location: distance between mouse and center of grab box, normalized in parent space. + float SliderGrabClickOffset; + float SliderCurrentAccum; // Accumulated slider delta when using navigation controls. + bool SliderCurrentAccumDirty; // Has the accumulated slider delta changed since last time we tried to apply it? + bool DragCurrentAccumDirty; + float DragCurrentAccum; // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings + float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio + float DisabledAlphaBackup; // Backup for style.Alpha for BeginDisabled() + short DisabledStackSize; + short TooltipOverrideCount; + ImGuiWindow* TooltipPreviousWindow; // Window of last tooltip submitted during the frame + ImVector_char ClipboardHandlerData; // If no custom clipboard handler is defined + ImVector_ImGuiID MenusIdSubmittedThisFrame; // A list of menu IDs that were rendered at least once + ImGuiTypingSelectState TypingSelectState; // State for GetTypingSelectRequest() + + // Platform support + ImGuiPlatformImeData PlatformImeData; // Data updated by current frame. Will be applied at end of the frame. For some backends, this is required to have WantVisible=true in order to receive text message. + ImGuiPlatformImeData PlatformImeDataPrev; // Previous frame data. When changed we call the platform_io.Platform_SetImeDataFn() handler. + + // Extensions + // FIXME: We could provide an API to register one slot in an array held in ImGuiContext? + ImVector_ImTextureDataPtr UserTextures; // List of textures created/managed by user or third-party extension. Automatically appended into platform_io.Textures[]. + ImGuiDockContext DockContext; + void (*DockNodeWindowMenuHandler)(ImGuiContext* ctx, ImGuiDockNode* node, ImGuiTabBar* tab_bar); + + // Settings + bool SettingsLoaded; + float SettingsDirtyTimer; // Save .ini Settings to memory when time reaches zero + ImGuiTextBuffer SettingsIniData; // In memory .ini settings + ImVector_ImGuiSettingsHandler SettingsHandlers; // List of .ini settings handlers + ImChunkStream_ImGuiWindowSettings SettingsWindows; // ImGuiWindow .ini settings entries + ImChunkStream_ImGuiTableSettings SettingsTables; // ImGuiTable .ini settings entries + ImVector_ImGuiContextHook Hooks; // Hooks for extensions (e.g. test engine) + ImGuiID HookIdNext; // Next available HookId + + // Localization + const char* LocalizationTable[ImGuiLocKey_COUNT]; + + // Capture/Logging + bool LogEnabled; // Currently capturing + ImGuiLogFlags LogFlags; // Capture flags/type + ImGuiWindow* LogWindow; + ImFileHandle LogFile; // If != NULL log to stdout/ file + ImGuiTextBuffer LogBuffer; // Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators. + const char* LogNextPrefix; + const char* LogNextSuffix; + float LogLinePosY; + bool LogLineFirstItem; + int LogDepthRef; + int LogDepthToExpand; + int LogDepthToExpandDefault; // Default/stored value for LogDepthMaxExpand if not specified in the LogXXX function call. + + // Error Handling + ImGuiErrorCallback ErrorCallback; // = NULL. May be exposed in public API eventually. + void* ErrorCallbackUserData; // = NULL + ImVec2 ErrorTooltipLockedPos; + bool ErrorFirst; + int ErrorCountCurrentFrame; // [Internal] Number of errors submitted this frame. + ImGuiErrorRecoveryState StackSizesInNewFrame; // [Internal] + ImGuiErrorRecoveryState* StackSizesInBeginForCurrentWindow; // [Internal] + + // Debug Tools + // (some of the highly frequently used data are interleaved in other structures above: DebugBreakXXX fields, DebugHookIdInfo, DebugLocateId etc.) + int DebugDrawIdConflictsCount; // Locked count (preserved when holding CTRL) + ImGuiDebugLogFlags DebugLogFlags; + ImGuiTextBuffer DebugLogBuf; + ImGuiTextIndex DebugLogIndex; + int DebugLogSkippedErrors; + ImGuiDebugLogFlags DebugLogAutoDisableFlags; + ImU8 DebugLogAutoDisableFrames; + ImU8 DebugLocateFrames; // For DebugLocateItemOnHover(). This is used together with DebugLocateId which is in a hot/cached spot above. + bool DebugBreakInLocateId; // Debug break in ItemAdd() call for g.DebugLocateId. + ImGuiKeyChord DebugBreakKeyChord; // = ImGuiKey_Pause + ImS8 DebugBeginReturnValueCullDepth; // Cycle between 0..9 then wrap around. + bool DebugItemPickerActive; // Item picker is active (started with DebugStartItemPicker()) + ImU8 DebugItemPickerMouseButton; + ImGuiID DebugItemPickerBreakId; // Will call IM_DEBUG_BREAK() when encountering this ID + float DebugFlashStyleColorTime; + ImVec4 DebugFlashStyleColorBackup; + ImGuiMetricsConfig DebugMetricsConfig; + ImGuiIDStackTool DebugIDStackTool; + ImGuiDebugAllocInfo DebugAllocInfo; + ImGuiDockNode* DebugHoveredDockNode; // Hovered dock node. +#if defined(IMGUI_DEBUG_HIGHLIGHT_ALL_ID_CONFLICTS)&&!defined(IMGUI_DISABLE_DEBUG_TOOLS) + ImGuiStorage DebugDrawIdConflictsAliveCount; + ImGuiStorage DebugDrawIdConflictsHighlightSet; +#endif // #if defined(IMGUI_DEBUG_HIGHLIGHT_ALL_ID_CONFLICTS)&&!defined(IMGUI_DISABLE_DEBUG_TOOLS) + // Misc + float FramerateSecPerFrame[60]; // Calculate estimate of framerate for user over the last 60 frames.. + int FramerateSecPerFrameIdx; + int FramerateSecPerFrameCount; + float FramerateSecPerFrameAccum; + int WantCaptureMouseNextFrame; // Explicit capture override via SetNextFrameWantCaptureMouse()/SetNextFrameWantCaptureKeyboard(). Default to -1. + int WantCaptureKeyboardNextFrame; // " + int WantTextInputNextFrame; // Copied in EndFrame() from g.PlatformImeData.WantTextInput. Needs to be set for some backends (SDL3) to emit character inputs. + ImVector_char TempBuffer; // Temporary text buffer + char TempKeychordName[64]; +}; + +//----------------------------------------------------------------------------- +// [SECTION] ImGuiWindowTempData, ImGuiWindow +//----------------------------------------------------------------------------- + +// Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow. +// (That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered..) +// (This doesn't need a constructor because we zero-clear it as part of ImGuiWindow and all frame-temporary data are setup on Begin) +struct ImGuiWindowTempData_t +{ + // Layout + ImVec2 CursorPos; // Current emitting position, in absolute coordinates. + ImVec2 CursorPosPrevLine; + ImVec2 CursorStartPos; // Initial position after Begin(), generally ~ window position + WindowPadding. + ImVec2 CursorMaxPos; // Used to implicitly calculate ContentSize at the beginning of next frame, for scrolling range and auto-resize. Always growing during the frame. + ImVec2 IdealMaxPos; // Used to implicitly calculate ContentSizeIdeal at the beginning of next frame, for auto-resize only. Always growing during the frame. + ImVec2 CurrLineSize; + ImVec2 PrevLineSize; + float CurrLineTextBaseOffset; // Baseline offset (0.0f by default on a new line, generally == style.FramePadding.y when a framed item has been added). + float PrevLineTextBaseOffset; + bool IsSameLine; + bool IsSetPos; + ImVec1 Indent; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.) + ImVec1 ColumnsOffset; // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API. + ImVec1 GroupOffset; + ImVec2 CursorStartPosLossyness; // Record the loss of precision of CursorStartPos due to really large scrolling amount. This is used by clipper to compensate and fix the most common use case of large scroll area. + + // Keyboard/Gamepad navigation + ImGuiNavLayer NavLayerCurrent; // Current layer, 0..31 (we currently only use 0..1) + short NavLayersActiveMask; // Which layers have been written to (result from previous frame) + short NavLayersActiveMaskNext; // Which layers have been written to (accumulator for current frame) + bool NavIsScrollPushableX; // Set when current work location may be scrolled horizontally when moving left / right. This is generally always true UNLESS within a column. + bool NavHideHighlightOneFrame; + bool NavWindowHasScrollY; // Set per window when scrolling can be used (== ScrollMax.y > 0.0f) + + // Miscellaneous + bool MenuBarAppending; // FIXME: Remove this + ImVec2 MenuBarOffset; // MenuBarOffset.x is sort of equivalent of a per-layer CursorPos.x, saved/restored as we switch to the menu bar. The only situation when MenuBarOffset.y is > 0 if when (SafeAreaPadding.y > FramePadding.y), often used on TVs. + ImGuiMenuColumns MenuColumns; // Simplified columns storage for menu items measurement + int TreeDepth; // Current tree depth. + ImU32 TreeHasStackDataDepthMask; // Store whether given depth has ImGuiTreeNodeStackData data. Could be turned into a ImU64 if necessary. + ImU32 TreeRecordsClippedNodesY2Mask; // Store whether we should keep recording Y2. Cleared when passing clip max. Equivalent TreeHasStackDataDepthMask value should always be set. + ImVector_ImGuiWindowPtr ChildWindows; + ImGuiStorage* StateStorage; // Current persistent per-window storage (store e.g. tree node open/close state) + ImGuiOldColumns* CurrentColumns; // Current columns set + int CurrentTableIdx; // Current table index (into g.Tables) + ImGuiLayoutType LayoutType; + ImGuiLayoutType ParentLayoutType; // Layout type of parent window at the time of Begin() + ImU32 ModalDimBgColor; + + // Status flags + ImGuiItemStatusFlags WindowItemStatusFlags; + ImGuiItemStatusFlags ChildItemStatusFlags; + ImGuiItemStatusFlags DockTabItemStatusFlags; + ImRect DockTabItemRect; + + // Local parameters stacks + // We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings. + float ItemWidth; // Current item width (>0.0: width in pixels, <0.0: align xx pixels to the right of window). + float TextWrapPos; // Current text wrap pos. + ImVector_float ItemWidthStack; // Store item widths to restore (attention: .back() is not == ItemWidth) + ImVector_float TextWrapPosStack; // Store text wrap pos to restore (attention: .back() is not == TextWrapPos) +}; + +// Storage for one window +struct ImGuiWindow_t +{ + ImGuiContext* Ctx; // Parent UI context (needs to be set explicitly by parent). + char* Name; // Window name, owned by the window. + ImGuiID ID; // == ImHashStr(Name) + ImGuiWindowFlags Flags, FlagsPreviousFrame; // See enum ImGuiWindowFlags_ + ImGuiChildFlags ChildFlags; // Set when window is a child window. See enum ImGuiChildFlags_ + ImGuiWindowClass WindowClass; // Advanced users only. Set with SetNextWindowClass() + ImGuiViewportP* Viewport; // Always set in Begin(). Inactive windows may have a NULL value here if their viewport was discarded. + ImGuiID ViewportId; // We backup the viewport id (since the viewport may disappear or never be created if the window is inactive) + ImVec2 ViewportPos; // We backup the viewport position (since the viewport may disappear or never be created if the window is inactive) + int ViewportAllowPlatformMonitorExtend; // Reset to -1 every frame (index is guaranteed to be valid between NewFrame..EndFrame), only used in the Appearing frame of a tooltip/popup to enforce clamping to a given monitor + ImVec2 Pos; // Position (always rounded-up to nearest pixel) + ImVec2 Size; // Current size (==SizeFull or collapsed title bar size) + ImVec2 SizeFull; // Size when non collapsed + ImVec2 ContentSize; // Size of contents/scrollable client area (calculated from the extents reach of the cursor) from previous frame. Does not include window decoration or window padding. + ImVec2 ContentSizeIdeal; + ImVec2 ContentSizeExplicit; // Size of contents/scrollable client area explicitly request by the user via SetNextWindowContentSize(). + ImVec2 WindowPadding; // Window padding at the time of Begin(). + float WindowRounding; // Window rounding at the time of Begin(). May be clamped lower to avoid rendering artifacts with title bar, menu bar etc. + float WindowBorderSize; // Window border size at the time of Begin(). + float TitleBarHeight, MenuBarHeight; // Note that those used to be function before 2024/05/28. If you have old code calling TitleBarHeight() you can change it to TitleBarHeight. + float DecoOuterSizeX1, DecoOuterSizeY1; // Left/Up offsets. Sum of non-scrolling outer decorations (X1 generally == 0.0f. Y1 generally = TitleBarHeight + MenuBarHeight). Locked during Begin(). + float DecoOuterSizeX2, DecoOuterSizeY2; // Right/Down offsets (X2 generally == ScrollbarSize.x, Y2 == ScrollbarSizes.y). + float DecoInnerSizeX1, DecoInnerSizeY1; // Applied AFTER/OVER InnerRect. Specialized for Tables as they use specialized form of clipping and frozen rows/columns are inside InnerRect (and not part of regular decoration sizes). + int NameBufLen; // Size of buffer storing Name. May be larger than strlen(Name)! + ImGuiID MoveId; // == window->GetID("#MOVE") + ImGuiID TabId; // == window->GetID("#TAB") + ImGuiID ChildId; // ID of corresponding item in parent window (for navigation to return from child window to parent window) + ImGuiID PopupId; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling) + ImVec2 Scroll; + ImVec2 ScrollMax; + ImVec2 ScrollTarget; // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change) + ImVec2 ScrollTargetCenterRatio; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered + ImVec2 ScrollTargetEdgeSnapDist; // 0.0f = no snapping, >0.0f snapping threshold + ImVec2 ScrollbarSizes; // Size taken by each scrollbars on their smaller axis. Pay attention! ScrollbarSizes.x == width of the vertical scrollbar, ScrollbarSizes.y = height of the horizontal scrollbar. + bool ScrollbarX, ScrollbarY; // Are scrollbars visible? + bool ScrollbarXStabilizeEnabled; // Was ScrollbarX previously auto-stabilized? + ImU8 ScrollbarXStabilizeToggledHistory; // Used to stabilize scrollbar visibility in case of feedback loops + bool ViewportOwned; + bool Active; // Set to true on Begin(), unless Collapsed + bool WasActive; + bool WriteAccessed; // Set to true when any widget access the current window + bool Collapsed; // Set when collapsing window to become only title-bar + bool WantCollapseToggle; + bool SkipItems; // Set when items can safely be all clipped (e.g. window not visible or collapsed) + bool SkipRefresh; // [EXPERIMENTAL] Reuse previous frame drawn contents, Begin() returns false. + bool Appearing; // Set during the frame where the window is appearing (or re-appearing) + bool Hidden; // Do not display (== HiddenFrames*** > 0) + bool IsFallbackWindow; // Set on the "Debug##Default" window. + bool IsExplicitChild; // Set when passed _ChildWindow, left to false by BeginDocked() + bool HasCloseButton; // Set when the window has a close button (p_open != NULL) + signed char ResizeBorderHovered; // Current border being hovered for resize (-1: none, otherwise 0-3) + signed char ResizeBorderHeld; // Current border being held for resize (-1: none, otherwise 0-3) + short BeginCount; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs) + short BeginCountPreviousFrame; // Number of Begin() during the previous frame + short BeginOrderWithinParent; // Begin() order within immediate parent window, if we are a child window. Otherwise 0. + short BeginOrderWithinContext; // Begin() order within entire imgui context. This is mostly used for debugging submission order related issues. + short FocusOrder; // Order within WindowsFocusOrder[], altered when windows are focused. + ImS8 AutoFitFramesX, AutoFitFramesY; + bool AutoFitOnlyGrows; + ImGuiDir AutoPosLastDirection; + ImS8 HiddenFramesCanSkipItems; // Hide the window for N frames + ImS8 HiddenFramesCannotSkipItems; // Hide the window for N frames while allowing items to be submitted so we can measure their size + ImS8 HiddenFramesForRenderOnly; // Hide the window until frame N at Render() time only + ImS8 DisableInputsFrames; // Disable window interactions for N frames + ImGuiCond SetWindowPosAllowFlags : 8; // store acceptable condition flags for SetNextWindowPos() use. + ImGuiCond SetWindowSizeAllowFlags : 8; // store acceptable condition flags for SetNextWindowSize() use. + ImGuiCond SetWindowCollapsedAllowFlags : 8; // store acceptable condition flags for SetNextWindowCollapsed() use. + ImGuiCond SetWindowDockAllowFlags : 8; // store acceptable condition flags for SetNextWindowDock() use. + ImVec2 SetWindowPosVal; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size) + ImVec2 SetWindowPosPivot; // store window pivot for positioning. ImVec2(0, 0) when positioning from top-left corner; ImVec2(0.5f, 0.5f) for centering; ImVec2(1, 1) for bottom right. + + ImVector_ImGuiID IDStack; // ID stack. ID are hashes seeded with the value at the top of the stack. (In theory this should be in the TempData structure) + ImGuiWindowTempData DC; // Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the "DC" variable name. + + // The best way to understand what those rectangles are is to use the 'Metrics->Tools->Show Windows Rectangles' viewer. + // The main 'OuterRect', omitted as a field, is window->Rect(). + ImRect OuterRectClipped; // == Window->Rect() just after setup in Begin(). == window->Rect() for root window. + ImRect InnerRect; // Inner rectangle (omit title bar, menu bar, scroll bar) + ImRect InnerClipRect; // == InnerRect shrunk by WindowPadding*0.5f on each side, clipped within viewport or parent clip rect. + ImRect WorkRect; // Initially covers the whole scrolling region. Reduced by containers e.g columns/tables when active. Shrunk by WindowPadding*1.0f on each side. This is meant to replace ContentRegionRect over time (from 1.71+ onward). + ImRect ParentWorkRect; // Backup of WorkRect before entering a container such as columns/tables. Used by e.g. SpanAllColumns functions to easily access. Stacked containers are responsible for maintaining this. // FIXME-WORKRECT: Could be a stack? + ImRect ClipRect; // Current clipping/scissoring rectangle, evolve as we are using PushClipRect(), etc. == DrawList->clip_rect_stack.back(). + ImRect ContentRegionRect; // FIXME: This is currently confusing/misleading. It is essentially WorkRect but not handling of scrolling. We currently rely on it as right/bottom aligned sizing operation need some size to rely on. + ImVec2ih HitTestHoleSize; // Define an optional rectangular hole where mouse will pass-through the window. + ImVec2ih HitTestHoleOffset; + + int LastFrameActive; // Last frame number the window was Active. + int LastFrameJustFocused; // Last frame number the window was made Focused. + float LastTimeActive; // Last timestamp the window was Active (using float as we don't need high precision there) + float ItemWidthDefault; + ImGuiStorage StateStorage; + ImVector_ImGuiOldColumns ColumnsStorage; + float FontWindowScale; // User scale multiplier per-window, via SetWindowFontScale() + float FontWindowScaleParents; + float FontRefSize; // This is a copy of window->CalcFontSize() at the time of Begin(), trying to phase out CalcFontSize() especially as it may be called on non-current window. + int SettingsOffset; // Offset into SettingsWindows[] (offsets are always valid as we only grow the array from the back) + + ImDrawList* DrawList; // == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer) + ImDrawList DrawListInst; + ImGuiWindow* ParentWindow; // If we are a child _or_ popup _or_ docked window, this is pointing to our parent. Otherwise NULL. + ImGuiWindow* ParentWindowInBeginStack; + ImGuiWindow* RootWindow; // Point to ourself or first ancestor that is not a child window. Doesn't cross through popups/dock nodes. + ImGuiWindow* RootWindowPopupTree; // Point to ourself or first ancestor that is not a child window. Cross through popups parent<>child. + ImGuiWindow* RootWindowDockTree; // Point to ourself or first ancestor that is not a child window. Cross through dock nodes. + ImGuiWindow* RootWindowForTitleBarHighlight; // Point to ourself or first ancestor which will display TitleBgActive color when this window is active. + ImGuiWindow* RootWindowForNav; // Point to ourself or first ancestor which doesn't have the NavFlattened flag. + ImGuiWindow* ParentWindowForFocusRoute; // Set to manual link a window to its logical parent so that Shortcut() chain are honoerd (e.g. Tool linked to Document) + + ImGuiWindow* NavLastChildNavWindow; // When going to the menu bar, we remember the child window we came from. (This could probably be made implicit if we kept g.Windows sorted by last focused including child window.) + ImGuiID NavLastIds[ImGuiNavLayer_COUNT]; // Last known NavId for this window, per layer (0/1) + ImRect NavRectRel[ImGuiNavLayer_COUNT]; // Reference rectangle, in window relative space + ImVec2 NavPreferredScoringPosRel[ImGuiNavLayer_COUNT]; // Preferred X/Y position updated when moving on a given axis, reset to FLT_MAX. + ImGuiID NavRootFocusScopeId; // Focus Scope ID at the time of Begin() + + int MemoryDrawListIdxCapacity; // Backup of last idx/vtx count, so when waking up the window we can preallocate and avoid iterative alloc/copy + int MemoryDrawListVtxCapacity; + bool MemoryCompacted; // Set when window extraneous data have been garbage collected + + // Docking + bool DockIsActive : 1; // When docking artifacts are actually visible. When this is set, DockNode is guaranteed to be != NULL. ~~ (DockNode != NULL) && (DockNode->Windows.Size > 1). + bool DockNodeIsVisible : 1; + bool DockTabIsVisible : 1; // Is our window visible this frame? ~~ is the corresponding tab selected? + bool DockTabWantClose : 1; + short DockOrder; // Order of the last time the window was visible within its DockNode. This is used to reorder windows that are reappearing on the same frame. Same value between windows that were active and windows that were none are possible. + ImGuiWindowDockStyle DockStyle; + ImGuiDockNode* DockNode; // Which node are we docked into. Important: Prefer testing DockIsActive in many cases as this will still be set when the dock node is hidden. + ImGuiDockNode* DockNodeAsHost; // Which node are we owning (for parent windows) + ImGuiID DockId; // Backup of last valid DockNode->ID, so single window remember their dock node id even when they are not bound any more + + // [Obsolete] ImGuiWindow::CalcFontSize() was removed in 1.92.x because error-prone/misleading. You can use window->FontRefSize for a copy of g.FontSize at the time of the last Begin() call for this window. + //float CalcFontSize() const { ImGuiContext& g = *Ctx; return g.FontSizeBase * FontWindowScale * FontDpiScale * FontWindowScaleParents; +}; +CIMGUI_API ImGuiID ImGuiWindow_GetIDStr(ImGuiWindow* self, const char* str); // Implied str_end = NULL +CIMGUI_API ImGuiID ImGuiWindow_GetIDStrEx(ImGuiWindow* self, const char* str, const char* str_end /* = NULL */); +CIMGUI_API ImGuiID ImGuiWindow_GetID(ImGuiWindow* self, const void* ptr); +CIMGUI_API ImGuiID ImGuiWindow_GetIDInt(ImGuiWindow* self, int n); +CIMGUI_API ImGuiID ImGuiWindow_GetIDFromPos(ImGuiWindow* self, ImVec2 p_abs); +CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self, ImRect r_abs); +// We don't use g.FontSize because the window may be != g.CurrentWindow. +CIMGUI_API ImRect ImGuiWindow_Rect(const ImGuiWindow* self); +CIMGUI_API ImRect ImGuiWindow_TitleBarRect(const ImGuiWindow* self); +CIMGUI_API ImRect ImGuiWindow_MenuBarRect(const ImGuiWindow* self); + +//----------------------------------------------------------------------------- +// [SECTION] Tab bar, Tab item support +//----------------------------------------------------------------------------- + +// Extend ImGuiTabBarFlags_ +typedef enum +{ + ImGuiTabBarFlags_DockNode = 1<<20, // Part of a dock node [we don't use this in the master branch but it facilitate branch syncing to keep this around] + ImGuiTabBarFlags_IsFocused = 1<<21, + ImGuiTabBarFlags_SaveSettings = 1<<22, // FIXME: Settings are handled by the docking system, this only request the tab bar to mark settings dirty when reordering tabs +} ImGuiTabBarFlagsPrivate_; + +// Extend ImGuiTabItemFlags_ +typedef enum +{ + ImGuiTabItemFlags_SectionMask_ = ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing, + ImGuiTabItemFlags_NoCloseButton = 1<<20, // Track whether p_open was set or not (we'll need this info on the next frame to recompute ContentWidth during layout) + ImGuiTabItemFlags_Button = 1<<21, // Used by TabItemButton, change the tab item behavior to mimic a button + ImGuiTabItemFlags_Invisible = 1<<22, // To reserve space e.g. with ImGuiTabItemFlags_Leading + ImGuiTabItemFlags_Unsorted = 1<<23, // [Docking] Trailing tabs with the _Unsorted flag will be sorted based on the DockOrder of their Window. +} ImGuiTabItemFlagsPrivate_; + +// Storage for one active tab item (sizeof() 48 bytes) +struct ImGuiTabItem_t +{ + ImGuiID ID; + ImGuiTabItemFlags Flags; + ImGuiWindow* Window; // When TabItem is part of a DockNode's TabBar, we hold on to a window. + int LastFrameVisible; + int LastFrameSelected; // This allows us to infer an ordered list of the last activated tabs with little maintenance + float Offset; // Position relative to beginning of tab + float Width; // Width currently displayed + float ContentWidth; // Width of label + padding, stored during BeginTabItem() call (misnamed as "Content" would normally imply width of label only) + float RequestedWidth; // Width optionally requested by caller, -1.0f is unused + ImS32 NameOffset; // When Window==NULL, offset to name within parent ImGuiTabBar::TabsNames + ImS16 BeginOrder; // BeginTabItem() order, used to re-order tabs after toggling ImGuiTabBarFlags_Reorderable + ImS16 IndexDuringLayout; // Index only used during TabBarLayout(). Tabs gets reordered so 'Tabs[n].IndexDuringLayout == n' but may mismatch during additions. + bool WantClose; // Marked as closed by SetTabItemClosed() +}; + +// Storage for a tab bar (sizeof() 160 bytes) +struct ImGuiTabBar_t +{ + ImGuiWindow* Window; + ImVector_ImGuiTabItem Tabs; + ImGuiTabBarFlags Flags; + ImGuiID ID; // Zero for tab-bars used by docking + ImGuiID SelectedTabId; // Selected tab/window + ImGuiID NextSelectedTabId; // Next selected tab/window. Will also trigger a scrolling animation + ImGuiID VisibleTabId; // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview) + int CurrFrameVisible; + int PrevFrameVisible; + ImRect BarRect; + float BarRectPrevWidth; // Backup of previous width. When width change we enforce keep horizontal scroll on focused tab. + float CurrTabsContentsHeight; + float PrevTabsContentsHeight; // Record the height of contents submitted below the tab bar + float WidthAllTabs; // Actual width of all tabs (locked during layout) + float WidthAllTabsIdeal; // Ideal width if all tabs were visible and not clipped + float ScrollingAnim; + float ScrollingTarget; + float ScrollingTargetDistToVisibility; + float ScrollingSpeed; + float ScrollingRectMinX; + float ScrollingRectMaxX; + float SeparatorMinX; + float SeparatorMaxX; + ImGuiID ReorderRequestTabId; + ImS16 ReorderRequestOffset; + ImS8 BeginCount; + bool WantLayout; + bool VisibleTabWasSubmitted; + bool TabsAddedNew; // Set to true when a new tab item or button has been added to the tab bar during last frame + bool ScrollButtonEnabled; + ImS16 TabsActiveCount; // Number of tabs submitted this frame. + ImS16 LastTabItemIdx; // Index of last BeginTabItem() tab for use by EndTabItem() + float ItemSpacingY; + ImVec2 FramePadding; // style.FramePadding locked at the time of BeginTabBar() + ImVec2 BackupCursorPos; + ImGuiTextBuffer TabsNames; // For non-docking tab bar we re-append names in a contiguous buffer. +}; + +//----------------------------------------------------------------------------- +// [SECTION] Table support +//----------------------------------------------------------------------------- + +#define IM_COL32_DISABLE IM_COL32(0,0,0,1) // Special sentinel code which cannot be used as a regular color. +#define IMGUI_TABLE_MAX_COLUMNS 512 // Arbitrary "safety" maximum, may be lifted in the future if needed. Must fit in ImGuiTableColumnIdx/ImGuiTableDrawChannelIdx. + +// [Internal] sizeof() ~ 112 +// We use the terminology "Enabled" to refer to a column that is not Hidden by user/api. +// We use the terminology "Clipped" to refer to a column that is out of sight because of scrolling/clipping. +// This is in contrast with some user-facing api such as IsItemVisible() / IsRectVisible() which use "Visible" to mean "not clipped". +struct ImGuiTableColumn_t +{ + ImGuiTableColumnFlags Flags; // Flags after some patching (not directly same as provided by user). See ImGuiTableColumnFlags_ + float WidthGiven; // Final/actual width visible == (MaxX - MinX), locked in TableUpdateLayout(). May be > WidthRequest to honor minimum width, may be < WidthRequest to honor shrinking columns down in tight space. + float MinX; // Absolute positions + float MaxX; + float WidthRequest; // Master width absolute value when !(Flags & _WidthStretch). When Stretch this is derived every frame from StretchWeight in TableUpdateLayout() + float WidthAuto; // Automatic width + float WidthMax; // Maximum width (FIXME: overwritten by each instance) + float StretchWeight; // Master width weight when (Flags & _WidthStretch). Often around ~1.0f initially. + float InitStretchWeightOrWidth; // Value passed to TableSetupColumn(). For Width it is a content width (_without padding_). + ImRect ClipRect; // Clipping rectangle for the column + ImGuiID UserID; // Optional, value passed to TableSetupColumn() + float WorkMinX; // Contents region min ~(MinX + CellPaddingX + CellSpacingX1) == cursor start position when entering column + float WorkMaxX; // Contents region max ~(MaxX - CellPaddingX - CellSpacingX2) + float ItemWidth; // Current item width for the column, preserved across rows + float ContentMaxXFrozen; // Contents maximum position for frozen rows (apart from headers), from which we can infer content width. + float ContentMaxXUnfrozen; + float ContentMaxXHeadersUsed; // Contents maximum position for headers rows (regardless of freezing). TableHeader() automatically softclip itself + report ideal desired size, to avoid creating extraneous draw calls + float ContentMaxXHeadersIdeal; + ImS16 NameOffset; // Offset into parent ColumnsNames[] + ImGuiTableColumnIdx DisplayOrder; // Index within Table's IndexToDisplayOrder[] (column may be reordered by users) + ImGuiTableColumnIdx IndexWithinEnabledSet; // Index within enabled/visible set (<= IndexToDisplayOrder) + ImGuiTableColumnIdx PrevEnabledColumn; // Index of prev enabled/visible column within Columns[], -1 if first enabled/visible column + ImGuiTableColumnIdx NextEnabledColumn; // Index of next enabled/visible column within Columns[], -1 if last enabled/visible column + ImGuiTableColumnIdx SortOrder; // Index of this column within sort specs, -1 if not sorting on this column, 0 for single-sort, may be >0 on multi-sort + ImGuiTableDrawChannelIdx DrawChannelCurrent; // Index within DrawSplitter.Channels[] + ImGuiTableDrawChannelIdx DrawChannelFrozen; // Draw channels for frozen rows (often headers) + ImGuiTableDrawChannelIdx DrawChannelUnfrozen; // Draw channels for unfrozen rows + bool IsEnabled; // IsUserEnabled && (Flags & ImGuiTableColumnFlags_Disabled) == 0 + bool IsUserEnabled; // Is the column not marked Hidden by the user? (unrelated to being off view, e.g. clipped by scrolling). + bool IsUserEnabledNextFrame; + bool IsVisibleX; // Is actually in view (e.g. overlapping the host window clipping rectangle, not scrolled). + bool IsVisibleY; + bool IsRequestOutput; // Return value for TableSetColumnIndex() / TableNextColumn(): whether we request user to output contents or not. + bool IsSkipItems; // Do we want item submissions to this column to be completely ignored (no layout will happen). + bool IsPreserveWidthAuto; + ImS8 NavLayerCurrent; // ImGuiNavLayer in 1 byte + ImU8 AutoFitQueue; // Queue of 8 values for the next 8 frames to request auto-fit + ImU8 CannotSkipItemsQueue; // Queue of 8 values for the next 8 frames to disable Clipped/SkipItem + ImU8 SortDirection : 2; // ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending + ImU8 SortDirectionsAvailCount : 2; // Number of available sort directions (0 to 3) + ImU8 SortDirectionsAvailMask : 4; // Mask of available sort directions (1-bit each) + ImU8 SortDirectionsAvailList; // Ordered list of available sort directions (2-bits each, total 8-bits) +}; + +// Transient cell data stored per row. +// sizeof() ~ 6 bytes +struct ImGuiTableCellData_t +{ + ImU32 BgColor; // Actual color + ImGuiTableColumnIdx Column; // Column number +}; + +// Parameters for TableAngledHeadersRowEx() +// This may end up being refactored for more general purpose. +// sizeof() ~ 12 bytes +struct ImGuiTableHeaderData_t +{ + ImGuiTableColumnIdx Index; // Column index + ImU32 TextColor; + ImU32 BgColor0; + ImU32 BgColor1; +}; + +// Per-instance data that needs preserving across frames (seemingly most others do not need to be preserved aside from debug needs. Does that means they could be moved to ImGuiTableTempData?) +// sizeof() ~ 24 bytes +struct ImGuiTableInstanceData_t +{ + ImGuiID TableInstanceID; + float LastOuterHeight; // Outer height from last frame + float LastTopHeadersRowHeight; // Height of first consecutive header rows from last frame (FIXME: this is used assuming consecutive headers are in same frozen set) + float LastFrozenHeight; // Height of frozen section from last frame + int HoveredRowLast; // Index of row which was hovered last frame. + int HoveredRowNext; // Index of row hovered this frame, set after encountering it. +}; + +// sizeof() ~ 592 bytes + heap allocs described in TableBeginInitMemory() +struct ImGuiTable_t +{ + ImGuiID ID; + ImGuiTableFlags Flags; + void* RawData; // Single allocation to hold Columns[], DisplayOrderToIndex[], and RowCellData[] + ImGuiTableTempData* TempData; // Transient data while table is active. Point within g.CurrentTableStack[] + ImSpan_ImGuiTableColumn Columns; // Point within RawData[] + ImSpan_ImGuiTableColumnIdx DisplayOrderToIndex; // Point within RawData[]. Store display order of columns (when not reordered, the values are 0...Count-1) + ImSpan_ImGuiTableCellData RowCellData; // Point within RawData[]. Store cells background requests for current row. + ImBitArrayPtr EnabledMaskByDisplayOrder; // Column DisplayOrder -> IsEnabled map + ImBitArrayPtr EnabledMaskByIndex; // Column Index -> IsEnabled map (== not hidden by user/api) in a format adequate for iterating column without touching cold data + ImBitArrayPtr VisibleMaskByIndex; // Column Index -> IsVisibleX|IsVisibleY map (== not hidden by user/api && not hidden by scrolling/cliprect) + ImGuiTableFlags SettingsLoadedFlags; // Which data were loaded from the .ini file (e.g. when order is not altered we won't save order) + int SettingsOffset; // Offset in g.SettingsTables + int LastFrameActive; + int ColumnsCount; // Number of columns declared in BeginTable() + int CurrentRow; + int CurrentColumn; + ImS16 InstanceCurrent; // Count of BeginTable() calls with same ID in the same frame (generally 0). This is a little bit similar to BeginCount for a window, but multiple tables with the same ID are multiple tables, they are just synced. + ImS16 InstanceInteracted; // Mark which instance (generally 0) of the same ID is being interacted with + float RowPosY1; + float RowPosY2; + float RowMinHeight; // Height submitted to TableNextRow() + float RowCellPaddingY; // Top and bottom padding. Reloaded during row change. + float RowTextBaseline; + float RowIndentOffsetX; + ImGuiTableRowFlags RowFlags : 16; // Current row flags, see ImGuiTableRowFlags_ + ImGuiTableRowFlags LastRowFlags : 16; + int RowBgColorCounter; // Counter for alternating background colors (can be fast-forwarded by e.g clipper), not same as CurrentRow because header rows typically don't increase this. + ImU32 RowBgColor[2]; // Background color override for current row. + ImU32 BorderColorStrong; + ImU32 BorderColorLight; + float BorderX1; + float BorderX2; + float HostIndentX; + float MinColumnWidth; + float OuterPaddingX; + float CellPaddingX; // Padding from each borders. Locked in BeginTable()/Layout. + float CellSpacingX1; // Spacing between non-bordered cells. Locked in BeginTable()/Layout. + float CellSpacingX2; + float InnerWidth; // User value passed to BeginTable(), see comments at the top of BeginTable() for details. + float ColumnsGivenWidth; // Sum of current column width + float ColumnsAutoFitWidth; // Sum of ideal column width in order nothing to be clipped, used for auto-fitting and content width submission in outer window + float ColumnsStretchSumWeights; // Sum of weight of all enabled stretching columns + float ResizedColumnNextWidth; + float ResizeLockMinContentsX2; // Lock minimum contents width while resizing down in order to not create feedback loops. But we allow growing the table. + float RefScale; // Reference scale to be able to rescale columns on font/dpi changes. + float AngledHeadersHeight; // Set by TableAngledHeadersRow(), used in TableUpdateLayout() + float AngledHeadersSlope; // Set by TableAngledHeadersRow(), used in TableUpdateLayout() + ImRect OuterRect; // Note: for non-scrolling table, OuterRect.Max.y is often FLT_MAX until EndTable(), unless a height has been specified in BeginTable(). + ImRect InnerRect; // InnerRect but without decoration. As with OuterRect, for non-scrolling tables, InnerRect.Max.y is " + ImRect WorkRect; + ImRect InnerClipRect; + ImRect BgClipRect; // We use this to cpu-clip cell background color fill, evolve during the frame as we cross frozen rows boundaries + ImRect Bg0ClipRectForDrawCmd; // Actual ImDrawCmd clip rect for BG0/1 channel. This tends to be == OuterWindow->ClipRect at BeginTable() because output in BG0/BG1 is cpu-clipped + ImRect Bg2ClipRectForDrawCmd; // Actual ImDrawCmd clip rect for BG2 channel. This tends to be a correct, tight-fit, because output to BG2 are done by widgets relying on regular ClipRect. + ImRect HostClipRect; // This is used to check if we can eventually merge our columns draw calls into the current draw call of the current window. + ImRect HostBackupInnerClipRect; // Backup of InnerWindow->ClipRect during PushTableBackground()/PopTableBackground() + ImGuiWindow* OuterWindow; // Parent window for the table + ImGuiWindow* InnerWindow; // Window holding the table data (== OuterWindow or a child window) + ImGuiTextBuffer ColumnsNames; // Contiguous buffer holding columns names + ImDrawListSplitter* DrawSplitter; // Shortcut to TempData->DrawSplitter while in table. Isolate draw commands per columns to avoid switching clip rect constantly + ImGuiTableInstanceData InstanceDataFirst; + ImVector_ImGuiTableInstanceData InstanceDataExtra; // FIXME-OPT: Using a small-vector pattern would be good. + ImGuiTableColumnSortSpecs SortSpecsSingle; + ImVector_ImGuiTableColumnSortSpecs SortSpecsMulti; // FIXME-OPT: Using a small-vector pattern would be good. + ImGuiTableSortSpecs SortSpecs; // Public facing sorts specs, this is what we return in TableGetSortSpecs() + ImGuiTableColumnIdx SortSpecsCount; + ImGuiTableColumnIdx ColumnsEnabledCount; // Number of enabled columns (<= ColumnsCount) + ImGuiTableColumnIdx ColumnsEnabledFixedCount; // Number of enabled columns using fixed width (<= ColumnsCount) + ImGuiTableColumnIdx DeclColumnsCount; // Count calls to TableSetupColumn() + ImGuiTableColumnIdx AngledHeadersCount; // Count columns with angled headers + ImGuiTableColumnIdx HoveredColumnBody; // Index of column whose visible region is being hovered. Important: == ColumnsCount when hovering empty region after the right-most column! + ImGuiTableColumnIdx HoveredColumnBorder; // Index of column whose right-border is being hovered (for resizing). + ImGuiTableColumnIdx HighlightColumnHeader; // Index of column which should be highlighted. + ImGuiTableColumnIdx AutoFitSingleColumn; // Index of single column requesting auto-fit. + ImGuiTableColumnIdx ResizedColumn; // Index of column being resized. Reset when InstanceCurrent==0. + ImGuiTableColumnIdx LastResizedColumn; // Index of column being resized from previous frame. + ImGuiTableColumnIdx HeldHeaderColumn; // Index of column header being held. + ImGuiTableColumnIdx ReorderColumn; // Index of column being reordered. (not cleared) + ImGuiTableColumnIdx ReorderColumnDir; // -1 or +1 + ImGuiTableColumnIdx LeftMostEnabledColumn; // Index of left-most non-hidden column. + ImGuiTableColumnIdx RightMostEnabledColumn; // Index of right-most non-hidden column. + ImGuiTableColumnIdx LeftMostStretchedColumn; // Index of left-most stretched column. + ImGuiTableColumnIdx RightMostStretchedColumn; // Index of right-most stretched column. + ImGuiTableColumnIdx ContextPopupColumn; // Column right-clicked on, of -1 if opening context menu from a neutral/empty spot + ImGuiTableColumnIdx FreezeRowsRequest; // Requested frozen rows count + ImGuiTableColumnIdx FreezeRowsCount; // Actual frozen row count (== FreezeRowsRequest, or == 0 when no scrolling offset) + ImGuiTableColumnIdx FreezeColumnsRequest; // Requested frozen columns count + ImGuiTableColumnIdx FreezeColumnsCount; // Actual frozen columns count (== FreezeColumnsRequest, or == 0 when no scrolling offset) + ImGuiTableColumnIdx RowCellDataCurrent; // Index of current RowCellData[] entry in current row + ImGuiTableDrawChannelIdx DummyDrawChannel; // Redirect non-visible columns here. + ImGuiTableDrawChannelIdx Bg2DrawChannelCurrent; // For Selectable() and other widgets drawing across columns after the freezing line. Index within DrawSplitter.Channels[] + ImGuiTableDrawChannelIdx Bg2DrawChannelUnfrozen; + ImS8 NavLayer; // ImGuiNavLayer at the time of BeginTable(). + bool IsLayoutLocked; // Set by TableUpdateLayout() which is called when beginning the first row. + bool IsInsideRow; // Set when inside TableBeginRow()/TableEndRow(). + bool IsInitializing; + bool IsSortSpecsDirty; + bool IsUsingHeaders; // Set when the first row had the ImGuiTableRowFlags_Headers flag. + bool IsContextPopupOpen; // Set when default context menu is open (also see: ContextPopupColumn, InstanceInteracted). + bool DisableDefaultContextMenu; // Disable default context menu. You may submit your own using TableBeginContextMenuPopup()/EndPopup() + bool IsSettingsRequestLoad; + bool IsSettingsDirty; // Set when table settings have changed and needs to be reported into ImGuiTableSetttings data. + bool IsDefaultDisplayOrder; // Set when display order is unchanged from default (DisplayOrder contains 0...Count-1) + bool IsResetAllRequest; + bool IsResetDisplayOrderRequest; + bool IsUnfrozenRows; // Set when we got past the frozen row. + bool IsDefaultSizingPolicy; // Set if user didn't explicitly set a sizing policy in BeginTable() + bool IsActiveIdAliveBeforeTable; + bool IsActiveIdInTable; + bool HasScrollbarYCurr; // Whether ANY instance of this table had a vertical scrollbar during the current frame. + bool HasScrollbarYPrev; // Whether ANY instance of this table had a vertical scrollbar during the previous. + bool MemoryCompacted; + bool HostSkipItems; // Backup of InnerWindow->SkipItem at the end of BeginTable(), because we will overwrite InnerWindow->SkipItem on a per-column basis +}; + +// Transient data that are only needed between BeginTable() and EndTable(), those buffers are shared (1 per level of stacked table). +// - Accessing those requires chasing an extra pointer so for very frequently used data we leave them in the main table structure. +// - We also leave out of this structure data that tend to be particularly useful for debugging/metrics. +// FIXME-TABLE: more transient data could be stored in a stacked ImGuiTableTempData: e.g. SortSpecs. +// sizeof() ~ 136 bytes. +struct ImGuiTableTempData_t +{ + int TableIndex; // Index in g.Tables.Buf[] pool + float LastTimeActive; // Last timestamp this structure was used + float AngledHeadersExtraWidth; // Used in EndTable() + ImVector_ImGuiTableHeaderData AngledHeadersRequests; // Used in TableAngledHeadersRow() + + ImVec2 UserOuterSize; // outer_size.x passed to BeginTable() + ImDrawListSplitter DrawSplitter; + + ImRect HostBackupWorkRect; // Backup of InnerWindow->WorkRect at the end of BeginTable() + ImRect HostBackupParentWorkRect; // Backup of InnerWindow->ParentWorkRect at the end of BeginTable() + ImVec2 HostBackupPrevLineSize; // Backup of InnerWindow->DC.PrevLineSize at the end of BeginTable() + ImVec2 HostBackupCurrLineSize; // Backup of InnerWindow->DC.CurrLineSize at the end of BeginTable() + ImVec2 HostBackupCursorMaxPos; // Backup of InnerWindow->DC.CursorMaxPos at the end of BeginTable() + ImVec1 HostBackupColumnsOffset; // Backup of OuterWindow->DC.ColumnsOffset at the end of BeginTable() + float HostBackupItemWidth; // Backup of OuterWindow->DC.ItemWidth at the end of BeginTable() + int HostBackupItemWidthStackSize; //Backup of OuterWindow->DC.ItemWidthStack.Size at the end of BeginTable() +}; + +// sizeof() ~ 16 +struct ImGuiTableColumnSettings_t +{ + float WidthOrWeight; + ImGuiID UserID; + ImGuiTableColumnIdx Index; + ImGuiTableColumnIdx DisplayOrder; + ImGuiTableColumnIdx SortOrder; + ImU8 SortDirection : 2; + ImS8 IsEnabled : 2; // "Visible" in ini file + ImU8 IsStretch : 1; +}; + +// This is designed to be stored in a single ImChunkStream (1 header followed by N ImGuiTableColumnSettings, etc.) +struct ImGuiTableSettings_t +{ + ImGuiID ID; // Set to 0 to invalidate/delete the setting + ImGuiTableFlags SaveFlags; // Indicate data we want to save using the Resizable/Reorderable/Sortable/Hideable flags (could be using its own flags..) + float RefScale; // Reference scale to be able to rescale columns on font/dpi changes. + ImGuiTableColumnIdx ColumnsCount; + ImGuiTableColumnIdx ColumnsCountMax; // Maximum number of columns this settings instance can store, we can recycle a settings instance with lower number of columns but not higher + bool WantApply; // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context) +}; +CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(ImGuiTableSettings* self); + +//----------------------------------------------------------------------------- +// [SECTION] ImGui internal API +// No guarantee of forward compatibility here! +//----------------------------------------------------------------------------- + +// Windows +// We should always have a CurrentWindow in the stack (there is an implicit "Debug" window) +// If this ever crashes because g.CurrentWindow is NULL, it means that either: +// - ImGui::NewFrame() has never been called, which is illegal. +// - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal. +CIMGUI_API ImGuiIO* ImGui_GetIOImGuiContextPtr(ImGuiContext* ctx); +CIMGUI_API ImGuiPlatformIO* ImGui_GetPlatformIOImGuiContextPtr(ImGuiContext* ctx); +CIMGUI_API ImGuiWindow* ImGui_GetCurrentWindowRead(void); +CIMGUI_API ImGuiWindow* ImGui_GetCurrentWindow(void); +CIMGUI_API ImGuiWindow* ImGui_FindWindowByID(ImGuiID id); +CIMGUI_API ImGuiWindow* ImGui_FindWindowByName(const char* name); +CIMGUI_API void ImGui_UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window); +CIMGUI_API void ImGui_UpdateWindowSkipRefresh(ImGuiWindow* window); +CIMGUI_API ImVec2 ImGui_CalcWindowNextAutoFitSize(ImGuiWindow* window); +CIMGUI_API bool ImGui_IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent, bool popup_hierarchy, bool dock_hierarchy); +CIMGUI_API bool ImGui_IsWindowWithinBeginStackOf(ImGuiWindow* window, ImGuiWindow* potential_parent); +CIMGUI_API bool ImGui_IsWindowAbove(ImGuiWindow* potential_above, ImGuiWindow* potential_below); +CIMGUI_API bool ImGui_IsWindowNavFocusable(ImGuiWindow* window); +CIMGUI_API void ImGui_SetWindowPosImGuiWindowPtr(ImGuiWindow* window, ImVec2 pos, ImGuiCond cond /* = 0 */); +CIMGUI_API void ImGui_SetWindowSizeImGuiWindowPtr(ImGuiWindow* window, ImVec2 size, ImGuiCond cond /* = 0 */); +CIMGUI_API void ImGui_SetWindowCollapsedImGuiWindowPtr(ImGuiWindow* window, bool collapsed, ImGuiCond cond /* = 0 */); +CIMGUI_API void ImGui_SetWindowHitTestHole(ImGuiWindow* window, ImVec2 pos, ImVec2 size); +CIMGUI_API void ImGui_SetWindowHiddenAndSkipItemsForCurrentFrame(ImGuiWindow* window); +CIMGUI_API void ImGui_SetWindowParentWindowForFocusRoute(ImGuiWindow* window, ImGuiWindow* parent_window); // You may also use SetNextWindowClass()'s FocusRouteParentWindowId field. +CIMGUI_API ImRect ImGui_WindowRectAbsToRel(ImGuiWindow* window, ImRect r); +CIMGUI_API ImRect ImGui_WindowRectRelToAbs(ImGuiWindow* window, ImRect r); +CIMGUI_API ImVec2 ImGui_WindowPosAbsToRel(ImGuiWindow* window, ImVec2 p); +CIMGUI_API ImVec2 ImGui_WindowPosRelToAbs(ImGuiWindow* window, ImVec2 p); + +// Windows: Display Order and Focus Order +CIMGUI_API void ImGui_FocusWindow(ImGuiWindow* window, ImGuiFocusRequestFlags flags /* = 0 */); +CIMGUI_API void ImGui_FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window, ImGuiViewport* filter_viewport, ImGuiFocusRequestFlags flags); +CIMGUI_API void ImGui_BringWindowToFocusFront(ImGuiWindow* window); +CIMGUI_API void ImGui_BringWindowToDisplayFront(ImGuiWindow* window); +CIMGUI_API void ImGui_BringWindowToDisplayBack(ImGuiWindow* window); +CIMGUI_API void ImGui_BringWindowToDisplayBehind(ImGuiWindow* window, ImGuiWindow* above_window); +CIMGUI_API int ImGui_FindWindowDisplayIndex(ImGuiWindow* window); +CIMGUI_API ImGuiWindow* ImGui_FindBottomMostVisibleWindowWithinBeginStack(ImGuiWindow* window); + +// Windows: Idle, Refresh Policies [EXPERIMENTAL] +CIMGUI_API void ImGui_SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags); + +// Fonts, drawing +CIMGUI_API void ImGui_RegisterUserTexture(ImTextureData* tex); // Register external texture. EXPERIMENTAL: DO NOT USE YET. +CIMGUI_API void ImGui_UnregisterUserTexture(ImTextureData* tex); +CIMGUI_API void ImGui_RegisterFontAtlas(ImFontAtlas* atlas); +CIMGUI_API void ImGui_UnregisterFontAtlas(ImFontAtlas* atlas); +CIMGUI_API void ImGui_SetCurrentFont(ImFont* font, float font_size_before_scaling, float font_size_after_scaling); +CIMGUI_API void ImGui_UpdateCurrentFontSize(float restore_font_size_after_scaling); +CIMGUI_API void ImGui_SetFontRasterizerDensity(float rasterizer_density); +CIMGUI_API float ImGui_GetFontRasterizerDensity(void); +CIMGUI_API float ImGui_GetRoundedFontSize(float size); +CIMGUI_API ImFont* ImGui_GetDefaultFont(void); +CIMGUI_API void ImGui_PushPasswordFont(void); +CIMGUI_API void ImGui_PopPasswordFont(void); +CIMGUI_API ImDrawList* ImGui_GetForegroundDrawListImGuiWindowPtr(ImGuiWindow* window); +CIMGUI_API void ImGui_AddDrawListToDrawDataEx(ImDrawData* draw_data, ImVector_ImDrawListPtr* out_list, ImDrawList* draw_list); + +// Init +CIMGUI_API void ImGui_Initialize(void); +CIMGUI_API void ImGui_Shutdown(void); // Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext(). + +// NewFrame +CIMGUI_API void ImGui_UpdateInputEvents(bool trickle_fast_inputs); +CIMGUI_API void ImGui_UpdateHoveredWindowAndCaptureFlags(ImVec2 mouse_pos); +CIMGUI_API void ImGui_FindHoveredWindowEx(ImVec2 pos, bool find_first_and_in_any_viewport, ImGuiWindow** out_hovered_window, ImGuiWindow** out_hovered_window_under_moving_window); +CIMGUI_API void ImGui_StartMouseMovingWindow(ImGuiWindow* window); +CIMGUI_API void ImGui_StartMouseMovingWindowOrNode(ImGuiWindow* window, ImGuiDockNode* node, bool undock); +CIMGUI_API void ImGui_StopMouseMovingWindow(void); +CIMGUI_API void ImGui_UpdateMouseMovingWindowNewFrame(void); +CIMGUI_API void ImGui_UpdateMouseMovingWindowEndFrame(void); + +// Generic context hooks +CIMGUI_API ImGuiID ImGui_AddContextHook(ImGuiContext* context, const ImGuiContextHook* hook); +CIMGUI_API void ImGui_RemoveContextHook(ImGuiContext* context, ImGuiID hook_to_remove); +CIMGUI_API void ImGui_CallContextHooks(ImGuiContext* context, ImGuiContextHookType type); + +// Viewports +CIMGUI_API void ImGui_TranslateWindowsInViewport(ImGuiViewportP* viewport, ImVec2 old_pos, ImVec2 new_pos, ImVec2 old_size, ImVec2 new_size); +CIMGUI_API void ImGui_ScaleWindowsInViewport(ImGuiViewportP* viewport, float scale); +CIMGUI_API void ImGui_DestroyPlatformWindow(ImGuiViewportP* viewport); +CIMGUI_API void ImGui_SetWindowViewport(ImGuiWindow* window, ImGuiViewportP* viewport); +CIMGUI_API void ImGui_SetCurrentViewport(ImGuiWindow* window, ImGuiViewportP* viewport); +CIMGUI_API const ImGuiPlatformMonitor* ImGui_GetViewportPlatformMonitor(ImGuiViewport* viewport); +CIMGUI_API ImGuiViewportP* ImGui_FindHoveredViewportFromPlatformWindowStack(ImVec2 mouse_platform_pos); + +// Settings +CIMGUI_API void ImGui_MarkIniSettingsDirty(void); +CIMGUI_API void ImGui_MarkIniSettingsDirtyImGuiWindowPtr(ImGuiWindow* window); +CIMGUI_API void ImGui_ClearIniSettings(void); +CIMGUI_API void ImGui_AddSettingsHandler(const ImGuiSettingsHandler* handler); +CIMGUI_API void ImGui_RemoveSettingsHandler(const char* type_name); +CIMGUI_API ImGuiSettingsHandler* ImGui_FindSettingsHandler(const char* type_name); + +// Settings - Windows +CIMGUI_API ImGuiWindowSettings* ImGui_CreateNewWindowSettings(const char* name); +CIMGUI_API ImGuiWindowSettings* ImGui_FindWindowSettingsByID(ImGuiID id); +CIMGUI_API ImGuiWindowSettings* ImGui_FindWindowSettingsByWindow(ImGuiWindow* window); +CIMGUI_API void ImGui_ClearWindowSettings(const char* name); + +// Localization +CIMGUI_API void ImGui_LocalizeRegisterEntries(const ImGuiLocEntry* entries, int count); +CIMGUI_API const char* ImGui_LocalizeGetMsg(ImGuiLocKey key); + +// Scrolling +CIMGUI_API void ImGui_SetScrollXImGuiWindowPtr(ImGuiWindow* window, float scroll_x); +CIMGUI_API void ImGui_SetScrollYImGuiWindowPtr(ImGuiWindow* window, float scroll_y); +CIMGUI_API void ImGui_SetScrollFromPosXImGuiWindowPtr(ImGuiWindow* window, float local_x, float center_x_ratio); +CIMGUI_API void ImGui_SetScrollFromPosYImGuiWindowPtr(ImGuiWindow* window, float local_y, float center_y_ratio); + +// Early work-in-progress API (ScrollToItem() will become public) +CIMGUI_API void ImGui_ScrollToItem(ImGuiScrollFlags flags /* = 0 */); +CIMGUI_API void ImGui_ScrollToRect(ImGuiWindow* window, ImRect rect, ImGuiScrollFlags flags /* = 0 */); +CIMGUI_API ImVec2 ImGui_ScrollToRectEx(ImGuiWindow* window, ImRect rect, ImGuiScrollFlags flags /* = 0 */); +//#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +CIMGUI_API void ImGui_ScrollToBringRectIntoView(ImGuiWindow* window, ImRect rect); +//#endif + +// Basic Accessors +CIMGUI_API ImGuiItemStatusFlags ImGui_GetItemStatusFlags(void); +CIMGUI_API ImGuiItemFlags ImGui_GetItemFlags(void); +CIMGUI_API ImGuiID ImGui_GetActiveID(void); +CIMGUI_API ImGuiID ImGui_GetFocusID(void); +CIMGUI_API void ImGui_SetActiveID(ImGuiID id, ImGuiWindow* window); +CIMGUI_API void ImGui_SetFocusID(ImGuiID id, ImGuiWindow* window); +CIMGUI_API void ImGui_ClearActiveID(void); +CIMGUI_API ImGuiID ImGui_GetHoveredID(void); +CIMGUI_API void ImGui_SetHoveredID(ImGuiID id); +CIMGUI_API void ImGui_KeepAliveID(ImGuiID id); +CIMGUI_API void ImGui_MarkItemEdited(ImGuiID id); // Mark data associated to given item as "edited", used by IsItemDeactivatedAfterEdit() function. +CIMGUI_API void ImGui_PushOverrideID(ImGuiID id); // Push given value as-is at the top of the ID stack (whereas PushID combines old and new hashes) +CIMGUI_API ImGuiID ImGui_GetIDWithSeedStr(const char* str_id_begin, const char* str_id_end, ImGuiID seed); +CIMGUI_API ImGuiID ImGui_GetIDWithSeed(int n, ImGuiID seed); + +// Basic Helpers for widget code +CIMGUI_API void ImGui_ItemSize(ImVec2 size); // Implied text_baseline_y = -1.0f +CIMGUI_API void ImGui_ItemSizeEx(ImVec2 size, float text_baseline_y /* = -1.0f */); +CIMGUI_API void ImGui_ItemSizeImRect(ImRect bb); // Implied text_baseline_y = -1.0f +CIMGUI_API void ImGui_ItemSizeImRectEx(ImRect bb, float text_baseline_y /* = -1.0f */); // FIXME: This is a misleading API since we expect CursorPos to be bb.Min. +CIMGUI_API bool ImGui_ItemAdd(ImRect bb, ImGuiID id); // Implied nav_bb = NULL, extra_flags = 0 +CIMGUI_API bool ImGui_ItemAddEx(ImRect bb, ImGuiID id, const ImRect* nav_bb /* = NULL */, ImGuiItemFlags extra_flags /* = 0 */); +CIMGUI_API bool ImGui_ItemHoverable(ImRect bb, ImGuiID id, ImGuiItemFlags item_flags); +CIMGUI_API bool ImGui_IsWindowContentHoverable(ImGuiWindow* window, ImGuiHoveredFlags flags /* = 0 */); +CIMGUI_API bool ImGui_IsClippedEx(ImRect bb, ImGuiID id); +CIMGUI_API void ImGui_SetLastItemData(ImGuiID item_id, ImGuiItemFlags item_flags, ImGuiItemStatusFlags status_flags, ImRect item_rect); +CIMGUI_API ImVec2 ImGui_CalcItemSize(ImVec2 size, float default_w, float default_h); +CIMGUI_API float ImGui_CalcWrapWidthForPos(ImVec2 pos, float wrap_pos_x); +CIMGUI_API void ImGui_PushMultiItemsWidths(int components, float width_full); +CIMGUI_API void ImGui_ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess, float width_min); + +// Parameter stacks (shared) +CIMGUI_API const ImGuiStyleVarInfo* ImGui_GetStyleVarInfo(ImGuiStyleVar idx); +CIMGUI_API void ImGui_BeginDisabledOverrideReenable(void); +CIMGUI_API void ImGui_EndDisabledOverrideReenable(void); + +// Logging/Capture +CIMGUI_API void ImGui_LogBegin(ImGuiLogFlags flags, int auto_open_depth); // -> BeginCapture() when we design v2 api, for now stay under the radar by using the old name. +CIMGUI_API void ImGui_LogToBuffer(void); // Implied auto_open_depth = -1 +CIMGUI_API void ImGui_LogToBufferEx(int auto_open_depth /* = -1 */); // Start logging/capturing to internal buffer +CIMGUI_API void ImGui_LogRenderedText(const ImVec2* ref_pos, const char* text); // Implied text_end = NULL +CIMGUI_API void ImGui_LogRenderedTextEx(const ImVec2* ref_pos, const char* text, const char* text_end /* = NULL */); +CIMGUI_API void ImGui_LogSetNextTextDecoration(const char* prefix, const char* suffix); + +// Childs +CIMGUI_API bool ImGui_BeginChildEx(const char* name, ImGuiID id, ImVec2 size_arg, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags); + +// Popups, Modals +CIMGUI_API bool ImGui_BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_window_flags); +CIMGUI_API bool ImGui_BeginPopupMenuEx(ImGuiID id, const char* label, ImGuiWindowFlags extra_window_flags); +CIMGUI_API void ImGui_OpenPopupEx(ImGuiID id); // Implied popup_flags = ImGuiPopupFlags_None +CIMGUI_API void ImGui_OpenPopupExEx(ImGuiID id, ImGuiPopupFlags popup_flags /* = ImGuiPopupFlags_None */); +CIMGUI_API void ImGui_ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup); +CIMGUI_API void ImGui_ClosePopupsOverWindow(ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup); +CIMGUI_API void ImGui_ClosePopupsExceptModals(void); +CIMGUI_API bool ImGui_IsPopupOpenID(ImGuiID id, ImGuiPopupFlags popup_flags); +CIMGUI_API ImRect ImGui_GetPopupAllowedExtentRect(ImGuiWindow* window); +CIMGUI_API ImGuiWindow* ImGui_GetTopMostPopupModal(void); +CIMGUI_API ImGuiWindow* ImGui_GetTopMostAndVisiblePopupModal(void); +CIMGUI_API ImGuiWindow* ImGui_FindBlockingModal(ImGuiWindow* window); +CIMGUI_API ImVec2 ImGui_FindBestWindowPosForPopup(ImGuiWindow* window); +CIMGUI_API ImVec2 ImGui_FindBestWindowPosForPopupEx(ImVec2 ref_pos, ImVec2 size, ImGuiDir* last_dir, ImRect r_outer, ImRect r_avoid, ImGuiPopupPositionPolicy policy); + +// Tooltips +CIMGUI_API bool ImGui_BeginTooltipEx(ImGuiTooltipFlags tooltip_flags, ImGuiWindowFlags extra_window_flags); +CIMGUI_API bool ImGui_BeginTooltipHidden(void); + +// Menus +CIMGUI_API bool ImGui_BeginViewportSideBar(const char* name, ImGuiViewport* viewport, ImGuiDir dir, float size, ImGuiWindowFlags window_flags); +CIMGUI_API bool ImGui_BeginMenuWithIcon(const char* label, const char* icon); // Implied enabled = true +CIMGUI_API bool ImGui_BeginMenuWithIconEx(const char* label, const char* icon, bool enabled /* = true */); +CIMGUI_API bool ImGui_MenuItemWithIcon(const char* label, const char* icon); // Implied shortcut = NULL, selected = false, enabled = true +CIMGUI_API bool ImGui_MenuItemWithIconEx(const char* label, const char* icon, const char* shortcut /* = NULL */, bool selected /* = false */, bool enabled /* = true */); + +// Combos +CIMGUI_API bool ImGui_BeginComboPopup(ImGuiID popup_id, ImRect bb, ImGuiComboFlags flags); +CIMGUI_API bool ImGui_BeginComboPreview(void); +CIMGUI_API void ImGui_EndComboPreview(void); + +// Keyboard/Gamepad Navigation +CIMGUI_API void ImGui_NavInitWindow(ImGuiWindow* window, bool force_reinit); +CIMGUI_API void ImGui_NavInitRequestApplyResult(void); +CIMGUI_API bool ImGui_NavMoveRequestButNoResultYet(void); +CIMGUI_API void ImGui_NavMoveRequestSubmit(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags); +CIMGUI_API void ImGui_NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags); +CIMGUI_API void ImGui_NavMoveRequestResolveWithLastItem(ImGuiNavItemData* result); +CIMGUI_API void ImGui_NavMoveRequestResolveWithPastTreeNode(ImGuiNavItemData* result, const ImGuiTreeNodeStackData* tree_node_data); +CIMGUI_API void ImGui_NavMoveRequestCancel(void); +CIMGUI_API void ImGui_NavMoveRequestApplyResult(void); +CIMGUI_API void ImGui_NavMoveRequestTryWrapping(ImGuiWindow* window, ImGuiNavMoveFlags move_flags); +CIMGUI_API void ImGui_NavHighlightActivated(ImGuiID id); +CIMGUI_API void ImGui_NavClearPreferredPosForAxis(ImGuiAxis axis); +CIMGUI_API void ImGui_SetNavCursorVisibleAfterMove(void); +CIMGUI_API void ImGui_NavUpdateCurrentWindowIsScrollPushableX(void); +CIMGUI_API void ImGui_SetNavWindow(ImGuiWindow* window); +CIMGUI_API void ImGui_SetNavID(ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, ImRect rect_rel); +CIMGUI_API void ImGui_SetNavFocusScope(ImGuiID focus_scope_id); + +// Focus/Activation +// This should be part of a larger set of API: FocusItem(offset = -1), FocusItemByID(id), ActivateItem(offset = -1), ActivateItemByID(id) etc. which are +// much harder to design and implement than expected. I have a couple of private branches on this matter but it's not simple. For now implementing the easy ones. +CIMGUI_API void ImGui_FocusItem(void); // Focus last item (no selection/activation). +CIMGUI_API void ImGui_ActivateItemByID(ImGuiID id); // Activate an item by ID (button, checkbox, tree node etc.). Activation is queued and processed on the next frame when the item is encountered again. Was called 'ActivateItem()' before 1.89.7. + +// Inputs +// FIXME: Eventually we should aim to move e.g. IsActiveIdUsingKey() into IsKeyXXX functions. +CIMGUI_API bool ImGui_IsNamedKey(ImGuiKey key); +CIMGUI_API bool ImGui_IsNamedKeyOrMod(ImGuiKey key); +CIMGUI_API bool ImGui_IsLegacyKey(ImGuiKey key); +CIMGUI_API bool ImGui_IsKeyboardKey(ImGuiKey key); +CIMGUI_API bool ImGui_IsGamepadKey(ImGuiKey key); +CIMGUI_API bool ImGui_IsMouseKey(ImGuiKey key); +CIMGUI_API bool ImGui_IsAliasKey(ImGuiKey key); +CIMGUI_API bool ImGui_IsLRModKey(ImGuiKey key); +CIMGUI_API ImGuiKeyChord ImGui_FixupKeyChord(ImGuiKeyChord key_chord); +CIMGUI_API ImGuiKey ImGui_ConvertSingleModFlagToKey(ImGuiKey key); + +CIMGUI_API ImGuiKeyData* ImGui_GetKeyDataImGuiContextPtr(ImGuiContext* ctx, ImGuiKey key); +CIMGUI_API ImGuiKeyData* ImGui_GetKeyData(ImGuiKey key); +CIMGUI_API const char* ImGui_GetKeyChordName(ImGuiKeyChord key_chord); +CIMGUI_API ImGuiKey ImGui_MouseButtonToKey(ImGuiMouseButton button); +CIMGUI_API bool ImGui_IsMouseDragPastThreshold(ImGuiMouseButton button); // Implied lock_threshold = -1.0f +CIMGUI_API bool ImGui_IsMouseDragPastThresholdEx(ImGuiMouseButton button, float lock_threshold /* = -1.0f */); +CIMGUI_API ImVec2 ImGui_GetKeyMagnitude2d(ImGuiKey key_left, ImGuiKey key_right, ImGuiKey key_up, ImGuiKey key_down); +CIMGUI_API float ImGui_GetNavTweakPressedAmount(ImGuiAxis axis); +CIMGUI_API int ImGui_CalcTypematicRepeatAmount(float t0, float t1, float repeat_delay, float repeat_rate); +CIMGUI_API void ImGui_GetTypematicRepeatRate(ImGuiInputFlags flags, float* repeat_delay, float* repeat_rate); +CIMGUI_API void ImGui_TeleportMousePos(ImVec2 pos); +CIMGUI_API void ImGui_SetActiveIdUsingAllKeyboardKeys(void); +CIMGUI_API bool ImGui_IsActiveIdUsingNavDir(ImGuiDir dir); + +// [EXPERIMENTAL] Low-Level: Key/Input Ownership +// - The idea is that instead of "eating" a given input, we can link to an owner id. +// - Ownership is most often claimed as a result of reacting to a press/down event (but occasionally may be claimed ahead). +// - Input queries can then read input by specifying ImGuiKeyOwner_Any (== 0), ImGuiKeyOwner_NoOwner (== -1) or a custom ID. +// - Legacy input queries (without specifying an owner or _Any or _None) are equivalent to using ImGuiKeyOwner_Any (== 0). +// - Input ownership is automatically released on the frame after a key is released. Therefore: +// - for ownership registration happening as a result of a down/press event, the SetKeyOwner() call may be done once (common case). +// - for ownership registration happening ahead of a down/press event, the SetKeyOwner() call needs to be made every frame (happens if e.g. claiming ownership on hover). +// - SetItemKeyOwner() is a shortcut for common simple case. A custom widget will probably want to call SetKeyOwner() multiple times directly based on its interaction state. +// - This is marked experimental because not all widgets are fully honoring the Set/Test idioms. We will need to move forward step by step. +// Please open a GitHub Issue to submit your usage scenario or if there's a use case you need solved. +CIMGUI_API ImGuiID ImGui_GetKeyOwner(ImGuiKey key); +CIMGUI_API void ImGui_SetKeyOwner(ImGuiKey key, ImGuiID owner_id, ImGuiInputFlags flags /* = 0 */); +CIMGUI_API void ImGui_SetKeyOwnersForKeyChord(ImGuiKeyChord key, ImGuiID owner_id, ImGuiInputFlags flags /* = 0 */); +CIMGUI_API void ImGui_SetItemKeyOwnerImGuiInputFlags(ImGuiKey key, ImGuiInputFlags flags); // Set key owner to last item if it is hovered or active. Equivalent to 'if (IsItemHovered() || IsItemActive()) { SetKeyOwner(key, GetItemID());'. +CIMGUI_API bool ImGui_TestKeyOwner(ImGuiKey key, ImGuiID owner_id); // Test that key is either not owned, either owned by 'owner_id' +CIMGUI_API ImGuiKeyOwnerData* ImGui_GetKeyOwnerData(ImGuiContext* ctx, ImGuiKey key); + +// [EXPERIMENTAL] High-Level: Input Access functions w/ support for Key/Input Ownership +// - Important: legacy IsKeyPressed(ImGuiKey, bool repeat=true) _DEFAULTS_ to repeat, new IsKeyPressed() requires _EXPLICIT_ ImGuiInputFlags_Repeat flag. +// - Expected to be later promoted to public API, the prototypes are designed to replace existing ones (since owner_id can default to Any == 0) +// - Specifying a value for 'ImGuiID owner' will test that EITHER the key is NOT owned (UNLESS locked), EITHER the key is owned by 'owner'. +// Legacy functions use ImGuiKeyOwner_Any meaning that they typically ignore ownership, unless a call to SetKeyOwner() explicitly used ImGuiInputFlags_LockThisFrame or ImGuiInputFlags_LockUntilRelease. +// - Binding generators may want to ignore those for now, or suffix them with Ex() until we decide if this gets moved into public API. +CIMGUI_API bool ImGui_IsKeyDownID(ImGuiKey key, ImGuiID owner_id); +CIMGUI_API bool ImGui_IsKeyPressedImGuiInputFlags(ImGuiKey key, ImGuiInputFlags flags); // Implied owner_id = 0 +CIMGUI_API bool ImGui_IsKeyPressedImGuiInputFlagsEx(ImGuiKey key, ImGuiInputFlags flags, ImGuiID owner_id /* = 0 */); // Important: when transitioning from old to new IsKeyPressed(): old API has "bool repeat = true", so would default to repeat. New API requiress explicit ImGuiInputFlags_Repeat. +CIMGUI_API bool ImGui_IsKeyReleasedID(ImGuiKey key, ImGuiID owner_id); +CIMGUI_API bool ImGui_IsKeyChordPressedImGuiInputFlags(ImGuiKeyChord key_chord, ImGuiInputFlags flags); // Implied owner_id = 0 +CIMGUI_API bool ImGui_IsKeyChordPressedImGuiInputFlagsEx(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id /* = 0 */); +CIMGUI_API bool ImGui_IsMouseDownID(ImGuiMouseButton button, ImGuiID owner_id); +CIMGUI_API bool ImGui_IsMouseClickedImGuiInputFlags(ImGuiMouseButton button, ImGuiInputFlags flags); // Implied owner_id = 0 +CIMGUI_API bool ImGui_IsMouseClickedImGuiInputFlagsEx(ImGuiMouseButton button, ImGuiInputFlags flags, ImGuiID owner_id /* = 0 */); +CIMGUI_API bool ImGui_IsMouseReleasedID(ImGuiMouseButton button, ImGuiID owner_id); +CIMGUI_API bool ImGui_IsMouseDoubleClickedID(ImGuiMouseButton button, ImGuiID owner_id); + +// Shortcut Testing & Routing +// - Set Shortcut() and SetNextItemShortcut() in imgui.h +// - When a policy (except for ImGuiInputFlags_RouteAlways *) is set, Shortcut() will register itself with SetShortcutRouting(), +// allowing the system to decide where to route the input among other route-aware calls. +// (* using ImGuiInputFlags_RouteAlways is roughly equivalent to calling IsKeyChordPressed(key) and bypassing route registration and check) +// - When using one of the routing option: +// - The default route is ImGuiInputFlags_RouteFocused (accept inputs if window is in focus stack. Deep-most focused window takes inputs. ActiveId takes inputs over deep-most focused window.) +// - Routes are requested given a chord (key + modifiers) and a routing policy. +// - Routes are resolved during NewFrame(): if keyboard modifiers are matching current ones: SetKeyOwner() is called + route is granted for the frame. +// - Each route may be granted to a single owner. When multiple requests are made we have policies to select the winning route (e.g. deep most window). +// - Multiple read sites may use the same owner id can all access the granted route. +// - When owner_id is 0 we use the current Focus Scope ID as a owner ID in order to identify our location. +// - You can chain two unrelated windows in the focus stack using SetWindowParentWindowForFocusRoute() +// e.g. if you have a tool window associated to a document, and you want document shortcuts to run when the tool is focused. +CIMGUI_API bool ImGui_ShortcutID(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id); +CIMGUI_API bool ImGui_SetShortcutRouting(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id); // owner_id needs to be explicit and cannot be 0 +CIMGUI_API bool ImGui_TestShortcutRouting(ImGuiKeyChord key_chord, ImGuiID owner_id); +CIMGUI_API ImGuiKeyRoutingData* ImGui_GetShortcutRoutingData(ImGuiKeyChord key_chord); + +// Docking +// (some functions are only declared in imgui.cpp, see Docking section) +CIMGUI_API void ImGui_DockContextInitialize(ImGuiContext* ctx); +CIMGUI_API void ImGui_DockContextShutdown(ImGuiContext* ctx); +CIMGUI_API void ImGui_DockContextClearNodes(ImGuiContext* ctx, ImGuiID root_id, bool clear_settings_refs); // Use root_id==0 to clear all +CIMGUI_API void ImGui_DockContextRebuildNodes(ImGuiContext* ctx); +CIMGUI_API void ImGui_DockContextNewFrameUpdateUndocking(ImGuiContext* ctx); +CIMGUI_API void ImGui_DockContextNewFrameUpdateDocking(ImGuiContext* ctx); +CIMGUI_API void ImGui_DockContextEndFrame(ImGuiContext* ctx); +CIMGUI_API ImGuiID ImGui_DockContextGenNodeID(ImGuiContext* ctx); +CIMGUI_API void ImGui_DockContextQueueDock(ImGuiContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer); +CIMGUI_API void ImGui_DockContextQueueUndockWindow(ImGuiContext* ctx, ImGuiWindow* window); +CIMGUI_API void ImGui_DockContextQueueUndockNode(ImGuiContext* ctx, ImGuiDockNode* node); +CIMGUI_API void ImGui_DockContextProcessUndockWindow(ImGuiContext* ctx, ImGuiWindow* window); // Implied clear_persistent_docking_ref = true +CIMGUI_API void ImGui_DockContextProcessUndockWindowEx(ImGuiContext* ctx, ImGuiWindow* window, bool clear_persistent_docking_ref /* = true */); +CIMGUI_API void ImGui_DockContextProcessUndockNode(ImGuiContext* ctx, ImGuiDockNode* node); +CIMGUI_API bool ImGui_DockContextCalcDropPosForDocking(ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload_window, ImGuiDockNode* payload_node, ImGuiDir split_dir, bool split_outer, ImVec2* out_pos); +CIMGUI_API ImGuiDockNode* ImGui_DockContextFindNodeByID(ImGuiContext* ctx, ImGuiID id); +CIMGUI_API void ImGui_DockNodeWindowMenuHandler_Default(ImGuiContext* ctx, ImGuiDockNode* node, ImGuiTabBar* tab_bar); +CIMGUI_API bool ImGui_DockNodeBeginAmendTabBar(ImGuiDockNode* node); +CIMGUI_API void ImGui_DockNodeEndAmendTabBar(void); +CIMGUI_API ImGuiDockNode* ImGui_DockNodeGetRootNode(ImGuiDockNode* node); +CIMGUI_API bool ImGui_DockNodeIsInHierarchyOf(ImGuiDockNode* node, ImGuiDockNode* parent); +CIMGUI_API int ImGui_DockNodeGetDepth(const ImGuiDockNode* node); +CIMGUI_API ImGuiID ImGui_DockNodeGetWindowMenuButtonId(const ImGuiDockNode* node); +CIMGUI_API ImGuiDockNode* ImGui_GetWindowDockNode(void); +CIMGUI_API bool ImGui_GetWindowAlwaysWantOwnTabBar(ImGuiWindow* window); +CIMGUI_API void ImGui_BeginDocked(ImGuiWindow* window, bool* p_open); +CIMGUI_API void ImGui_BeginDockableDragDropSource(ImGuiWindow* window); +CIMGUI_API void ImGui_BeginDockableDragDropTarget(ImGuiWindow* window); +CIMGUI_API void ImGui_SetWindowDock(ImGuiWindow* window, ImGuiID dock_id, ImGuiCond cond); + +// Docking - Builder function needs to be generally called before the node is used/submitted. +// - The DockBuilderXXX functions are designed to _eventually_ become a public API, but it is too early to expose it and guarantee stability. +// - Do not hold on ImGuiDockNode* pointers! They may be invalidated by any split/merge/remove operation and every frame. +// - To create a DockSpace() node, make sure to set the ImGuiDockNodeFlags_DockSpace flag when calling DockBuilderAddNode(). +// You can create dockspace nodes (attached to a window) _or_ floating nodes (carry its own window) with this API. +// - DockBuilderSplitNode() create 2 child nodes within 1 node. The initial node becomes a parent node. +// - If you intend to split the node immediately after creation using DockBuilderSplitNode(), make sure +// to call DockBuilderSetNodeSize() beforehand. If you don't, the resulting split sizes may not be reliable. +// - Call DockBuilderFinish() after you are done. +CIMGUI_API void ImGui_DockBuilderDockWindow(const char* window_name, ImGuiID node_id); +CIMGUI_API ImGuiDockNode* ImGui_DockBuilderGetNode(ImGuiID node_id); +CIMGUI_API ImGuiDockNode* ImGui_DockBuilderGetCentralNode(ImGuiID node_id); +CIMGUI_API ImGuiID ImGui_DockBuilderAddNode(void); // Implied node_id = 0, flags = 0 +CIMGUI_API ImGuiID ImGui_DockBuilderAddNodeEx(ImGuiID node_id /* = 0 */, ImGuiDockNodeFlags flags /* = 0 */); +CIMGUI_API void ImGui_DockBuilderRemoveNode(ImGuiID node_id); // Remove node and all its child, undock all windows +CIMGUI_API void ImGui_DockBuilderRemoveNodeDockedWindows(ImGuiID node_id); // Implied clear_settings_refs = true +CIMGUI_API void ImGui_DockBuilderRemoveNodeDockedWindowsEx(ImGuiID node_id, bool clear_settings_refs /* = true */); +CIMGUI_API void ImGui_DockBuilderRemoveNodeChildNodes(ImGuiID node_id); // Remove all split/hierarchy. All remaining docked windows will be re-docked to the remaining root node (node_id). +CIMGUI_API void ImGui_DockBuilderSetNodePos(ImGuiID node_id, ImVec2 pos); +CIMGUI_API void ImGui_DockBuilderSetNodeSize(ImGuiID node_id, ImVec2 size); +CIMGUI_API ImGuiID ImGui_DockBuilderSplitNode(ImGuiID node_id, ImGuiDir split_dir, float size_ratio_for_node_at_dir, ImGuiID* out_id_at_dir, ImGuiID* out_id_at_opposite_dir); // Create 2 child nodes in this parent node. +CIMGUI_API void ImGui_DockBuilderCopyDockSpace(ImGuiID src_dockspace_id, ImGuiID dst_dockspace_id, ImVector_const_charPtr* in_window_remap_pairs); +CIMGUI_API void ImGui_DockBuilderCopyNode(ImGuiID src_node_id, ImGuiID dst_node_id, ImVector_ImGuiID* out_node_remap_pairs); +CIMGUI_API void ImGui_DockBuilderCopyWindowSettings(const char* src_name, const char* dst_name); +CIMGUI_API void ImGui_DockBuilderFinish(ImGuiID node_id); + +// [EXPERIMENTAL] Focus Scope +// This is generally used to identify a unique input location (for e.g. a selection set) +// There is one per window (automatically set in Begin), but: +// - Selection patterns generally need to react (e.g. clear a selection) when landing on one item of the set. +// So in order to identify a set multiple lists in same window may each need a focus scope. +// If you imagine an hypothetical BeginSelectionGroup()/EndSelectionGroup() api, it would likely call PushFocusScope()/EndFocusScope() +// - Shortcut routing also use focus scope as a default location identifier if an owner is not provided. +// We don't use the ID Stack for this as it is common to want them separate. +CIMGUI_API void ImGui_PushFocusScope(ImGuiID id); +CIMGUI_API void ImGui_PopFocusScope(void); +CIMGUI_API ImGuiID ImGui_GetCurrentFocusScope(void); // Focus scope we are outputting into, set by PushFocusScope() + +// Drag and Drop +CIMGUI_API bool ImGui_IsDragDropActive(void); +CIMGUI_API bool ImGui_BeginDragDropTargetCustom(ImRect bb, ImGuiID id); +CIMGUI_API void ImGui_ClearDragDrop(void); +CIMGUI_API bool ImGui_IsDragDropPayloadBeingAccepted(void); +CIMGUI_API void ImGui_RenderDragDropTargetRect(ImRect bb, ImRect item_clip_rect); + +// Typing-Select API +// (provide Windows Explorer style "select items by typing partial name" + "cycle through items by typing same letter" feature) +// (this is currently not documented nor used by main library, but should work. See "widgets_typingselect" in imgui_test_suite for usage code. Please let us know if you use this!) +CIMGUI_API ImGuiTypingSelectRequest* ImGui_GetTypingSelectRequest(void); // Implied flags = ImGuiTypingSelectFlags_None +CIMGUI_API ImGuiTypingSelectRequest* ImGui_GetTypingSelectRequestEx(ImGuiTypingSelectFlags flags /* = ImGuiTypingSelectFlags_None */); +CIMGUI_API int ImGui_TypingSelectFindMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx); +CIMGUI_API int ImGui_TypingSelectFindNextSingleCharMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx); +CIMGUI_API int ImGui_TypingSelectFindBestLeadingMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data); + +// Box-Select API +CIMGUI_API bool ImGui_BeginBoxSelect(ImRect scope_rect, ImGuiWindow* window, ImGuiID box_select_id, ImGuiMultiSelectFlags ms_flags); +CIMGUI_API void ImGui_EndBoxSelect(ImRect scope_rect, ImGuiMultiSelectFlags ms_flags); + +// Multi-Select API +CIMGUI_API void ImGui_MultiSelectItemHeader(ImGuiID id, bool* p_selected, ImGuiButtonFlags* p_button_flags); +CIMGUI_API void ImGui_MultiSelectItemFooter(ImGuiID id, bool* p_selected, bool* p_pressed); +CIMGUI_API void ImGui_MultiSelectAddSetAll(ImGuiMultiSelectTempData* ms, bool selected); +CIMGUI_API void ImGui_MultiSelectAddSetRange(ImGuiMultiSelectTempData* ms, bool selected, int range_dir, ImGuiSelectionUserData first_item, ImGuiSelectionUserData last_item); +CIMGUI_API ImGuiBoxSelectState* ImGui_GetBoxSelectState(ImGuiID id); +CIMGUI_API ImGuiMultiSelectState* ImGui_GetMultiSelectState(ImGuiID id); + +// Internal Columns API (this is not exposed because we will encourage transitioning to the Tables API) +CIMGUI_API void ImGui_SetWindowClipRectBeforeSetChannel(ImGuiWindow* window, ImRect clip_rect); +CIMGUI_API void ImGui_BeginColumns(const char* str_id, int count, ImGuiOldColumnFlags flags /* = 0 */); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns(). +CIMGUI_API void ImGui_EndColumns(void); // close columns +CIMGUI_API void ImGui_PushColumnClipRect(int column_index); +CIMGUI_API void ImGui_PushColumnsBackground(void); +CIMGUI_API void ImGui_PopColumnsBackground(void); +CIMGUI_API ImGuiID ImGui_GetColumnsID(const char* str_id, int count); +CIMGUI_API ImGuiOldColumns* ImGui_FindOrCreateColumns(ImGuiWindow* window, ImGuiID id); +CIMGUI_API float ImGui_GetColumnOffsetFromNorm(const ImGuiOldColumns* columns, float offset_norm); +CIMGUI_API float ImGui_GetColumnNormFromOffset(const ImGuiOldColumns* columns, float offset); + +// Tables: Candidates for public API +CIMGUI_API void ImGui_TableOpenContextMenu(void); // Implied column_n = -1 +CIMGUI_API void ImGui_TableOpenContextMenuEx(int column_n /* = -1 */); +CIMGUI_API void ImGui_TableSetColumnWidth(int column_n, float width); +CIMGUI_API void ImGui_TableSetColumnSortDirection(int column_n, ImGuiSortDirection sort_direction, bool append_to_sort_specs); +CIMGUI_API int ImGui_TableGetHoveredRow(void); // Retrieve *PREVIOUS FRAME* hovered row. This difference with TableGetHoveredColumn() is the reason why this is not public yet. +CIMGUI_API float ImGui_TableGetHeaderRowHeight(void); +CIMGUI_API float ImGui_TableGetHeaderAngledMaxLabelWidth(void); +CIMGUI_API void ImGui_TablePushBackgroundChannel(void); +CIMGUI_API void ImGui_TablePopBackgroundChannel(void); +CIMGUI_API void ImGui_TablePushColumnChannel(int column_n); +CIMGUI_API void ImGui_TablePopColumnChannel(void); +CIMGUI_API void ImGui_TableAngledHeadersRowEx(ImGuiID row_id, float angle, float max_label_width, const ImGuiTableHeaderData* data, int data_count); + +// Tables: Internals +CIMGUI_API ImGuiTable* ImGui_GetCurrentTable(void); +CIMGUI_API ImGuiTable* ImGui_TableFindByID(ImGuiID id); +CIMGUI_API bool ImGui_BeginTableWithID(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags /* = 0 */); // Implied outer_size = ImVec2(0, 0), inner_width = 0.0f +CIMGUI_API bool ImGui_BeginTableWithIDEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags /* = 0 */, ImVec2 outer_size /* = ImVec2(0, 0) */, float inner_width /* = 0.0f */); +CIMGUI_API void ImGui_TableBeginInitMemory(ImGuiTable* table, int columns_count); +CIMGUI_API void ImGui_TableBeginApplyRequests(ImGuiTable* table); +CIMGUI_API void ImGui_TableSetupDrawChannels(ImGuiTable* table); +CIMGUI_API void ImGui_TableUpdateLayout(ImGuiTable* table); +CIMGUI_API void ImGui_TableUpdateBorders(ImGuiTable* table); +CIMGUI_API void ImGui_TableUpdateColumnsWeightFromWidth(ImGuiTable* table); +CIMGUI_API void ImGui_TableDrawBorders(ImGuiTable* table); +CIMGUI_API void ImGui_TableDrawDefaultContextMenu(ImGuiTable* table, ImGuiTableFlags flags_for_section_to_display); +CIMGUI_API bool ImGui_TableBeginContextMenuPopup(ImGuiTable* table); +CIMGUI_API void ImGui_TableMergeDrawChannels(ImGuiTable* table); +CIMGUI_API ImGuiTableInstanceData* ImGui_TableGetInstanceData(ImGuiTable* table, int instance_no); +CIMGUI_API ImGuiID ImGui_TableGetInstanceID(ImGuiTable* table, int instance_no); +CIMGUI_API void ImGui_TableSortSpecsSanitize(ImGuiTable* table); +CIMGUI_API void ImGui_TableSortSpecsBuild(ImGuiTable* table); +CIMGUI_API ImGuiSortDirection ImGui_TableGetColumnNextSortDirection(ImGuiTableColumn* column); +CIMGUI_API void ImGui_TableFixColumnSortDirection(ImGuiTable* table, ImGuiTableColumn* column); +CIMGUI_API float ImGui_TableGetColumnWidthAuto(ImGuiTable* table, ImGuiTableColumn* column); +CIMGUI_API void ImGui_TableBeginRow(ImGuiTable* table); +CIMGUI_API void ImGui_TableEndRow(ImGuiTable* table); +CIMGUI_API void ImGui_TableBeginCell(ImGuiTable* table, int column_n); +CIMGUI_API void ImGui_TableEndCell(ImGuiTable* table); +CIMGUI_API ImRect ImGui_TableGetCellBgRect(const ImGuiTable* table, int column_n); +CIMGUI_API const char* ImGui_TableGetColumnNameImGuiTablePtr(const ImGuiTable* table, int column_n); +CIMGUI_API ImGuiID ImGui_TableGetColumnResizeID(ImGuiTable* table, int column_n); // Implied instance_no = 0 +CIMGUI_API ImGuiID ImGui_TableGetColumnResizeIDEx(ImGuiTable* table, int column_n, int instance_no /* = 0 */); +CIMGUI_API float ImGui_TableCalcMaxColumnWidth(const ImGuiTable* table, int column_n); +CIMGUI_API void ImGui_TableSetColumnWidthAutoSingle(ImGuiTable* table, int column_n); +CIMGUI_API void ImGui_TableSetColumnWidthAutoAll(ImGuiTable* table); +CIMGUI_API void ImGui_TableRemove(ImGuiTable* table); +CIMGUI_API void ImGui_TableGcCompactTransientBuffers(ImGuiTable* table); +CIMGUI_API void ImGui_TableGcCompactTransientBuffersImGuiTableTempDataPtr(ImGuiTableTempData* table); +CIMGUI_API void ImGui_TableGcCompactSettings(void); + +// Tables: Settings +CIMGUI_API void ImGui_TableLoadSettings(ImGuiTable* table); +CIMGUI_API void ImGui_TableSaveSettings(ImGuiTable* table); +CIMGUI_API void ImGui_TableResetSettings(ImGuiTable* table); +CIMGUI_API ImGuiTableSettings* ImGui_TableGetBoundSettings(ImGuiTable* table); +CIMGUI_API void ImGui_TableSettingsAddSettingsHandler(void); +CIMGUI_API ImGuiTableSettings* ImGui_TableSettingsCreate(ImGuiID id, int columns_count); +CIMGUI_API ImGuiTableSettings* ImGui_TableSettingsFindByID(ImGuiID id); + +// Tab Bars +CIMGUI_API ImGuiTabBar* ImGui_GetCurrentTabBar(void); +CIMGUI_API bool ImGui_BeginTabBarEx(ImGuiTabBar* tab_bar, ImRect bb, ImGuiTabBarFlags flags); +CIMGUI_API ImGuiTabItem* ImGui_TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id); +CIMGUI_API ImGuiTabItem* ImGui_TabBarFindTabByOrder(ImGuiTabBar* tab_bar, int order); +CIMGUI_API ImGuiTabItem* ImGui_TabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBar* tab_bar); +CIMGUI_API ImGuiTabItem* ImGui_TabBarGetCurrentTab(ImGuiTabBar* tab_bar); +CIMGUI_API int ImGui_TabBarGetTabOrder(ImGuiTabBar* tab_bar, ImGuiTabItem* tab); +CIMGUI_API const char* ImGui_TabBarGetTabName(ImGuiTabBar* tab_bar, ImGuiTabItem* tab); +CIMGUI_API void ImGui_TabBarAddTab(ImGuiTabBar* tab_bar, ImGuiTabItemFlags tab_flags, ImGuiWindow* window); +CIMGUI_API void ImGui_TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id); +CIMGUI_API void ImGui_TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab); +CIMGUI_API void ImGui_TabBarQueueFocus(ImGuiTabBar* tab_bar, ImGuiTabItem* tab); +CIMGUI_API void ImGui_TabBarQueueFocusStr(ImGuiTabBar* tab_bar, const char* tab_name); +CIMGUI_API void ImGui_TabBarQueueReorder(ImGuiTabBar* tab_bar, ImGuiTabItem* tab, int offset); +CIMGUI_API void ImGui_TabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar, ImGuiTabItem* tab, ImVec2 mouse_pos); +CIMGUI_API bool ImGui_TabBarProcessReorder(ImGuiTabBar* tab_bar); +CIMGUI_API bool ImGui_TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags, ImGuiWindow* docked_window); +CIMGUI_API void ImGui_TabItemSpacing(const char* str_id, ImGuiTabItemFlags flags, float width); +CIMGUI_API ImVec2 ImGui_TabItemCalcSizeStr(const char* label, bool has_close_button_or_unsaved_marker); +CIMGUI_API ImVec2 ImGui_TabItemCalcSize(ImGuiWindow* window); +CIMGUI_API void ImGui_TabItemBackground(ImDrawList* draw_list, ImRect bb, ImGuiTabItemFlags flags, ImU32 col); +CIMGUI_API void ImGui_TabItemLabelAndCloseButton(ImDrawList* draw_list, 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); + +// Render helpers +// AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT. +// NB: All position are in absolute pixels coordinates (we are never using window coordinates internally) +CIMGUI_API void ImGui_RenderText(ImVec2 pos, const char* text); // Implied text_end = NULL, hide_text_after_hash = true +CIMGUI_API void ImGui_RenderTextEx(ImVec2 pos, const char* text, const char* text_end /* = NULL */, bool hide_text_after_hash /* = true */); +CIMGUI_API void ImGui_RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width); +CIMGUI_API void ImGui_RenderTextClipped(ImVec2 pos_min, ImVec2 pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known); // Implied align = ImVec2(0, 0), clip_rect = NULL +CIMGUI_API void ImGui_RenderTextClippedEx(ImVec2 pos_min, ImVec2 pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, ImVec2 align /* = ImVec2(0, 0) */, const ImRect* clip_rect /* = NULL */); +CIMGUI_API void ImGui_RenderTextClippedWithDrawList(ImDrawList* draw_list, ImVec2 pos_min, ImVec2 pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known); // Implied align = ImVec2(0, 0), clip_rect = NULL +CIMGUI_API void ImGui_RenderTextClippedWithDrawListEx(ImDrawList* draw_list, ImVec2 pos_min, ImVec2 pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, ImVec2 align /* = ImVec2(0, 0) */, const ImRect* clip_rect /* = NULL */); +CIMGUI_API void ImGui_RenderTextEllipsis(ImDrawList* draw_list, ImVec2 pos_min, ImVec2 pos_max, float ellipsis_max_x, const char* text, const char* text_end, const ImVec2* text_size_if_known); +CIMGUI_API void ImGui_RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col); // Implied borders = true, rounding = 0.0f +CIMGUI_API void ImGui_RenderFrameEx(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool borders /* = true */, float rounding /* = 0.0f */); +CIMGUI_API void ImGui_RenderFrameBorder(ImVec2 p_min, ImVec2 p_max); // Implied rounding = 0.0f +CIMGUI_API void ImGui_RenderFrameBorderEx(ImVec2 p_min, ImVec2 p_max, float rounding /* = 0.0f */); +CIMGUI_API void ImGui_RenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list, ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off); // Implied rounding = 0.0f, flags = 0 +CIMGUI_API void ImGui_RenderColorRectWithAlphaCheckerboardEx(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 */); +CIMGUI_API void ImGui_RenderNavCursor(ImRect bb, ImGuiID id); // Implied flags = ImGuiNavRenderCursorFlags_None +CIMGUI_API void ImGui_RenderNavCursorEx(ImRect bb, ImGuiID id, ImGuiNavRenderCursorFlags flags /* = ImGuiNavRenderCursorFlags_None */); // Navigation highlight +#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +CIMGUI_API void ImGui_RenderNavHighlight(ImRect bb, ImGuiID id); // Implied flags = ImGuiNavRenderCursorFlags_None +CIMGUI_API void ImGui_RenderNavHighlightEx(ImRect bb, ImGuiID id, ImGuiNavRenderCursorFlags flags /* = ImGuiNavRenderCursorFlags_None */); // Renamed in 1.91.4 +#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +CIMGUI_API const char* ImGui_FindRenderedTextEnd(const char* text); // Implied text_end = NULL +CIMGUI_API const char* ImGui_FindRenderedTextEndEx(const char* text, const char* text_end /* = NULL */); // Find the optional ## from which we stop displaying text. +CIMGUI_API void ImGui_RenderMouseCursor(ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow); + +// Render helpers (those functions don't access any ImGui state!) +CIMGUI_API void ImGui_RenderArrow(ImDrawList* draw_list, ImVec2 pos, ImU32 col, ImGuiDir dir); // Implied scale = 1.0f +CIMGUI_API void ImGui_RenderArrowEx(ImDrawList* draw_list, ImVec2 pos, ImU32 col, ImGuiDir dir, float scale /* = 1.0f */); +CIMGUI_API void ImGui_RenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col); +CIMGUI_API void ImGui_RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float sz); +CIMGUI_API void ImGui_RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col); +CIMGUI_API void ImGui_RenderArrowDockMenu(ImDrawList* draw_list, ImVec2 p_min, float sz, ImU32 col); +CIMGUI_API void ImGui_RenderRectFilledRangeH(ImDrawList* draw_list, ImRect rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding); +CIMGUI_API void ImGui_RenderRectFilledWithHole(ImDrawList* draw_list, ImRect outer, ImRect inner, ImU32 col, float rounding); +CIMGUI_API ImDrawFlags ImGui_CalcRoundingFlagsForRectInRect(ImRect r_in, ImRect r_outer, float threshold); + +// Widgets: Text +CIMGUI_API void ImGui_TextEx(const char* text); // Implied text_end = NULL, flags = 0 +CIMGUI_API void ImGui_TextExEx(const char* text, const char* text_end /* = NULL */, ImGuiTextFlags flags /* = 0 */); +CIMGUI_API void ImGui_TextAligned(float align_x, float size_x, const char* fmt, ...); // FIXME-WIP: Works but API is likely to be reworked. This is designed for 1 item on the line. (#7024) +CIMGUI_API void ImGui_TextAlignedV(float align_x, float size_x, const char* fmt, va_list args); + +// Widgets +CIMGUI_API bool ImGui_ButtonWithFlags(const char* label); // Implied size_arg = ImVec2(0, 0), flags = 0 +CIMGUI_API bool ImGui_ButtonWithFlagsEx(const char* label, ImVec2 size_arg /* = ImVec2(0, 0) */, ImGuiButtonFlags flags /* = 0 */); +CIMGUI_API bool ImGui_ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags /* = 0 */); +CIMGUI_API bool ImGui_ImageButtonWithFlags(ImGuiID id, ImTextureRef tex_ref, ImVec2 image_size, ImVec2 uv0, ImVec2 uv1, ImVec4 bg_col, ImVec4 tint_col, ImGuiButtonFlags flags /* = 0 */); +CIMGUI_API void ImGui_SeparatorEx(ImGuiSeparatorFlags flags); // Implied thickness = 1.0f +CIMGUI_API void ImGui_SeparatorExEx(ImGuiSeparatorFlags flags, float thickness /* = 1.0f */); +CIMGUI_API void ImGui_SeparatorTextEx(ImGuiID id, const char* label, const char* label_end, float extra_width); +CIMGUI_API bool ImGui_CheckboxFlagsImS64Ptr(const char* label, ImS64* flags, ImS64 flags_value); +CIMGUI_API bool ImGui_CheckboxFlagsImU64Ptr(const char* label, ImU64* flags, ImU64 flags_value); + +// Widgets: Window Decorations +CIMGUI_API bool ImGui_CloseButton(ImGuiID id, ImVec2 pos); +CIMGUI_API bool ImGui_CollapseButton(ImGuiID id, ImVec2 pos, ImGuiDockNode* dock_node); +CIMGUI_API void ImGui_Scrollbar(ImGuiAxis axis); +CIMGUI_API bool ImGui_ScrollbarEx(ImRect bb, ImGuiID id, ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v); // Implied draw_rounding_flags = 0 +CIMGUI_API bool ImGui_ScrollbarExEx(ImRect bb, ImGuiID id, ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v, ImDrawFlags draw_rounding_flags /* = 0 */); +CIMGUI_API ImRect ImGui_GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis); +CIMGUI_API ImGuiID ImGui_GetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis); +CIMGUI_API ImGuiID ImGui_GetWindowResizeCornerID(ImGuiWindow* window, int n); // 0..3: corners +CIMGUI_API ImGuiID ImGui_GetWindowResizeBorderID(ImGuiWindow* window, ImGuiDir dir); + +// Widgets low-level behaviors +CIMGUI_API bool ImGui_ButtonBehavior(ImRect bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags /* = 0 */); +CIMGUI_API bool ImGui_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); +CIMGUI_API bool ImGui_SliderBehavior(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); +CIMGUI_API bool ImGui_SplitterBehavior(ImRect bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2); // Implied hover_extend = 0.0f, hover_visibility_delay = 0.0f, bg_col = 0 +CIMGUI_API bool ImGui_SplitterBehaviorEx(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 */); + +// Widgets: Tree Nodes +CIMGUI_API bool ImGui_TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label); // Implied label_end = NULL +CIMGUI_API bool ImGui_TreeNodeBehaviorEx(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end /* = NULL */); +CIMGUI_API void ImGui_TreeNodeDrawLineToChildNode(ImVec2 target_pos); +CIMGUI_API void ImGui_TreeNodeDrawLineToTreePop(const ImGuiTreeNodeStackData* data); +CIMGUI_API void ImGui_TreePushOverrideID(ImGuiID id); +CIMGUI_API bool ImGui_TreeNodeGetOpen(ImGuiID storage_id); +CIMGUI_API void ImGui_TreeNodeSetOpen(ImGuiID storage_id, bool open); +CIMGUI_API bool ImGui_TreeNodeUpdateNextOpen(ImGuiID storage_id, ImGuiTreeNodeFlags flags); // Return open state. Consume previous SetNextItemOpen() data, if any. May return true when logging. + +// Data type helpers +CIMGUI_API const ImGuiDataTypeInfo* ImGui_DataTypeGetInfo(ImGuiDataType data_type); +CIMGUI_API int ImGui_DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* p_data, const char* format); +CIMGUI_API void ImGui_DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, const void* arg_1, const void* arg_2); +CIMGUI_API bool ImGui_DataTypeApplyFromText(const char* buf, ImGuiDataType data_type, void* p_data, const char* format); // Implied p_data_when_empty = NULL +CIMGUI_API bool ImGui_DataTypeApplyFromTextEx(const char* buf, ImGuiDataType data_type, void* p_data, const char* format, void* p_data_when_empty /* = NULL */); +CIMGUI_API int ImGui_DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2); +CIMGUI_API bool ImGui_DataTypeClamp(ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max); +CIMGUI_API bool ImGui_DataTypeIsZero(ImGuiDataType data_type, const void* p_data); + +// InputText +CIMGUI_API bool ImGui_InputTextWithHintAndSize(const char* label, const char* hint, char* buf, int buf_size, ImVec2 size_arg, ImGuiInputTextFlags flags); // Implied callback = NULL, user_data = NULL +CIMGUI_API bool ImGui_InputTextWithHintAndSizeEx(const char* label, const char* hint, char* buf, int buf_size, ImVec2 size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback /* = NULL */, void* user_data /* = NULL */); +CIMGUI_API void ImGui_InputTextDeactivateHook(ImGuiID id); +CIMGUI_API bool ImGui_TempInputText(ImRect bb, ImGuiID id, const char* label, char* buf, int buf_size, ImGuiInputTextFlags flags); +CIMGUI_API bool ImGui_TempInputScalar(ImRect bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format); // Implied p_clamp_min = NULL, p_clamp_max = NULL +CIMGUI_API bool ImGui_TempInputScalarEx(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 */); +CIMGUI_API bool ImGui_TempInputIsActive(ImGuiID id); +CIMGUI_API void ImGui_SetNextItemRefVal(ImGuiDataType data_type, void* p_data); +CIMGUI_API bool ImGui_IsItemActiveAsInputText(void); // This may be useful to apply workaround that a based on distinguish whenever an item is active as a text input field. + +// Color +CIMGUI_API void ImGui_ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags); +CIMGUI_API void ImGui_ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags); +CIMGUI_API void ImGui_ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags); + +// Plot +CIMGUI_API int ImGui_PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 size_arg); + +// Shade functions (write over already created vertices) +CIMGUI_API void ImGui_ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1); +CIMGUI_API void ImGui_ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 a, ImVec2 b, ImVec2 uv_a, ImVec2 uv_b, bool clamp); +CIMGUI_API void ImGui_ShadeVertsTransformPos(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 pivot_in, float cos_a, float sin_a, ImVec2 pivot_out); + +// Garbage collection +CIMGUI_API void ImGui_GcCompactTransientMiscBuffers(void); +CIMGUI_API void ImGui_GcCompactTransientWindowBuffers(ImGuiWindow* window); +CIMGUI_API void ImGui_GcAwakeTransientWindowBuffers(ImGuiWindow* window); + +// Error handling, State Recovery +CIMGUI_API bool ImGui_ErrorLog(const char* msg); +CIMGUI_API void ImGui_ErrorRecoveryStoreState(ImGuiErrorRecoveryState* state_out); +CIMGUI_API void ImGui_ErrorRecoveryTryToRecoverState(const ImGuiErrorRecoveryState* state_in); +CIMGUI_API void ImGui_ErrorRecoveryTryToRecoverWindowState(const ImGuiErrorRecoveryState* state_in); +CIMGUI_API void ImGui_ErrorCheckUsingSetCursorPosToExtendParentBoundaries(void); +CIMGUI_API void ImGui_ErrorCheckEndFrameFinalizeErrorTooltip(void); +CIMGUI_API bool ImGui_BeginErrorTooltip(void); +CIMGUI_API void ImGui_EndErrorTooltip(void); + +// Debug Tools +CIMGUI_API void ImGui_DebugAllocHook(ImGuiDebugAllocInfo* info, int frame_count, void* ptr, size_t size); // size >= 0 : alloc, size = -1 : free +CIMGUI_API void ImGui_DebugDrawCursorPos(void); // Implied col = IM_COL32(255, 0, 0, 255) +CIMGUI_API void ImGui_DebugDrawCursorPosEx(ImU32 col /* = IM_COL32(255, 0, 0, 255) */); +CIMGUI_API void ImGui_DebugDrawLineExtents(void); // Implied col = IM_COL32(255, 0, 0, 255) +CIMGUI_API void ImGui_DebugDrawLineExtentsEx(ImU32 col /* = IM_COL32(255, 0, 0, 255) */); +CIMGUI_API void ImGui_DebugDrawItemRect(void); // Implied col = IM_COL32(255, 0, 0, 255) +CIMGUI_API void ImGui_DebugDrawItemRectEx(ImU32 col /* = IM_COL32(255, 0, 0, 255) */); +CIMGUI_API void ImGui_DebugTextUnformattedWithLocateItem(const char* line_begin, const char* line_end); +CIMGUI_API void ImGui_DebugLocateItem(ImGuiID target_id); // Call sparingly: only 1 at the same time! +CIMGUI_API void ImGui_DebugLocateItemOnHover(ImGuiID target_id); // Only call on reaction to a mouse Hover: because only 1 at the same time! +CIMGUI_API void ImGui_DebugLocateItemResolveWithLastItem(void); +CIMGUI_API void ImGui_DebugBreakClearData(void); +CIMGUI_API bool ImGui_DebugBreakButton(const char* label, const char* description_of_location); +CIMGUI_API void ImGui_DebugBreakButtonTooltip(bool keyboard_only, const char* description_of_location); +CIMGUI_API void ImGui_ShowFontAtlas(ImFontAtlas* atlas); +CIMGUI_API void ImGui_DebugHookIdInfo(ImGuiID id, ImGuiDataType data_type, const void* data_id, const void* data_id_end); +CIMGUI_API void ImGui_DebugNodeColumns(ImGuiOldColumns* columns); +CIMGUI_API void ImGui_DebugNodeDockNode(ImGuiDockNode* node, const char* label); +CIMGUI_API void ImGui_DebugNodeDrawList(ImGuiWindow* window, ImGuiViewportP* viewport, const ImDrawList* draw_list, const char* label); +CIMGUI_API void ImGui_DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawList* out_draw_list, const ImDrawList* draw_list, const ImDrawCmd* draw_cmd, bool show_mesh, bool show_aabb); +CIMGUI_API void ImGui_DebugNodeFont(ImFont* font); +CIMGUI_API void ImGui_DebugNodeFontGlyphesForSrcMask(ImFont* font, ImFontBaked* baked, int src_mask); +CIMGUI_API void ImGui_DebugNodeFontGlyph(ImFont* font, const ImFontGlyph* glyph); +CIMGUI_API void ImGui_DebugNodeTexture(ImTextureData* tex, int int_id); // Implied highlight_rect = NULL +CIMGUI_API void ImGui_DebugNodeTextureEx(ImTextureData* tex, int int_id, const ImFontAtlasRect* highlight_rect /* = NULL */); // ID used to facilitate persisting the "current" texture. +CIMGUI_API void ImGui_DebugNodeStorage(ImGuiStorage* storage, const char* label); +CIMGUI_API void ImGui_DebugNodeTabBar(ImGuiTabBar* tab_bar, const char* label); +CIMGUI_API void ImGui_DebugNodeTable(ImGuiTable* table); +CIMGUI_API void ImGui_DebugNodeTableSettings(ImGuiTableSettings* settings); +CIMGUI_API void ImGui_DebugNodeTypingSelectState(ImGuiTypingSelectState* state); +CIMGUI_API void ImGui_DebugNodeMultiSelectState(ImGuiMultiSelectState* state); +CIMGUI_API void ImGui_DebugNodeWindow(ImGuiWindow* window, const char* label); +CIMGUI_API void ImGui_DebugNodeWindowSettings(ImGuiWindowSettings* settings); +CIMGUI_API void ImGui_DebugNodeWindowsList(ImVector_ImGuiWindowPtr* windows, const char* label); +CIMGUI_API void ImGui_DebugNodeWindowsListByBeginStackParent(ImGuiWindow** windows, int windows_size, ImGuiWindow* parent_in_begin_stack); +CIMGUI_API void ImGui_DebugNodeViewport(ImGuiViewportP* viewport); +CIMGUI_API void ImGui_DebugNodePlatformMonitor(ImGuiPlatformMonitor* monitor, const char* label, int idx); +CIMGUI_API void ImGui_DebugRenderKeyboardPreview(ImDrawList* draw_list); +CIMGUI_API void ImGui_DebugRenderViewportThumbnail(ImDrawList* draw_list, ImGuiViewportP* viewport, ImRect bb); + +//----------------------------------------------------------------------------- +// [SECTION] ImFontLoader +//----------------------------------------------------------------------------- + +// Hooks and storage for a given font backend. +// This structure is likely to evolve as we add support for incremental atlas updates. +// Conceptually this could be public, but API is still going to be evolve. +struct ImFontLoader_t +{ + const char* Name; + bool (*LoaderInit)(ImFontAtlas* atlas); + void (*LoaderShutdown)(ImFontAtlas* atlas); + bool (*FontSrcInit)(ImFontAtlas* atlas, ImFontConfig* src); + void (*FontSrcDestroy)(ImFontAtlas* atlas, ImFontConfig* src); + bool (*FontSrcContainsGlyph)(ImFontAtlas* atlas, ImFontConfig* src, ImWchar codepoint); + bool (*FontBakedInit)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src); + void (*FontBakedDestroy)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src); + bool (*FontBakedLoadGlyph)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src, ImWchar codepoint, ImFontGlyph* out_glyph, float* out_advance_x); + + // Size of backend data, Per Baked * Per Source. Buffers are managed by core to avoid excessive allocations. + // FIXME: At this point the two other types of buffers may be managed by core to be consistent? + size_t FontBakedSrcLoaderDataSize; +}; + +#ifdef IMGUI_ENABLE_STB_TRUETYPE +CIMGUI_API const ImFontLoader* cImFontAtlasGetFontLoaderForStbTruetype(void); +#endif // #ifdef IMGUI_ENABLE_STB_TRUETYPE +#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +typedef ImFontLoader ImFontBuilderIO; // [renamed/changed in 1.92] The types are not actually compatible but we provide this as a compile-time error report helper. +#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS +//----------------------------------------------------------------------------- +// [SECTION] ImFontAtlas internal API +//----------------------------------------------------------------------------- + +#define IMGUI_FONT_SIZE_MAX (512.0f) +#define IMGUI_FONT_SIZE_THRESHOLD_FOR_LOADADVANCEXONLYMODE (128.0f) + +// Refer to ImFontAtlasPackGetRect() to better understand how this works. +#define ImFontAtlasRectId_IndexMask_ (0x000FFFFF) // 20-bits: index to access builder->RectsIndex[]. +#define ImFontAtlasRectId_GenerationMask_ (0x3FF00000) // 10-bits: entry generation, so each ID is unique and get can safely detected old identifiers. +#define ImFontAtlasRectId_GenerationShift_ (20) +CIMGUI_API int cImFontAtlasRectId_GetIndex(ImFontAtlasRectId id); +CIMGUI_API int cImFontAtlasRectId_GetGeneration(ImFontAtlasRectId id); +CIMGUI_API ImFontAtlasRectId cImFontAtlasRectId_Make(int index_idx, int gen_idx); + +// Packed rectangle lookup entry (we need an indirection to allow removing/reordering rectangles) +// User are returned ImFontAtlasRectId values which are meant to be persistent. +// We handle this with an indirection. While Rects[] may be in theory shuffled, compacted etc., RectsIndex[] cannot it is keyed by ImFontAtlasRectId. +// RectsIndex[] is used both as an index into Rects[] and an index into itself. This is basically a free-list. See ImFontAtlasBuildAllocRectIndexEntry() code. +// Having this also makes it easier to e.g. sort rectangles during repack. +struct ImFontAtlasRectEntry_t +{ + int TargetIndex : 20; // When Used: ImFontAtlasRectId -> into Rects[]. When unused: index to next unused RectsIndex[] slot to consume free-list. + int Generation : 10; // Increased each time the entry is reused for a new rectangle. + unsigned int IsUsed : 1; +}; +struct ImVector_ImFontAtlasRectEntry_t { int Size; int Capacity; ImFontAtlasRectEntry* Data; }; // Instantiation of ImVector + +// Data available to potential texture post-processing functions +struct ImFontAtlasPostProcessData_t +{ + ImFontAtlas* FontAtlas; + ImFont* Font; + ImFontConfig* FontSrc; + ImFontBaked* FontBaked; + ImFontGlyph* Glyph; + + // Pixel data + void* Pixels; + ImTextureFormat Format; + int Pitch; + int Width; + int Height; +}; + +// We avoid dragging imstb_rectpack.h into public header (partly because binding generators are having issues with it) +#ifdef IMGUI_STB_NAMESPACE +typedef struct IMGUI_STB_NAMESPACEstbrp_node_t IMGUI_STB_NAMESPACEstbrp_node; +typedef IMGUI_STB_NAMESPACE::stbrp_node stbrp_node_im; +#else +typedef struct stbrp_node_t stbrp_node; +typedef stbrp_node stbrp_node_im; +struct ImVector_stbrp_node_im_t { int Size; int Capacity; stbrp_node_im* Data; }; // Instantiation of ImVector +#endif // #ifdef IMGUI_STB_NAMESPACE +struct stbrp_context_opaque_t +{ + char data[80]; +}; + +// Internal storage for incrementally packing and building a ImFontAtlas +struct ImFontAtlasBuilder_t +{ + stbrp_context_opaque PackContext; // Actually 'stbrp_context' but we don't want to define this in the header file. + ImVector_stbrp_node_im PackNodes; + ImVector_ImTextureRect Rects; + ImVector_ImFontAtlasRectEntry RectsIndex; // ImFontAtlasRectId -> index into Rects[] + ImVector_unsigned_char TempBuffer; // Misc scratch buffer + int RectsIndexFreeListStart; // First unused entry + int RectsPackedCount; // Number of packed rectangles. + int RectsPackedSurface; // Number of packed pixels. Used when compacting to heuristically find the ideal texture size. + int RectsDiscardedCount; + int RectsDiscardedSurface; + int FrameCount; // Current frame count + ImVec2i MaxRectSize; // Largest rectangle to pack (de-facto used as a "minimum texture size") + ImVec2i MaxRectBounds; // Bottom-right most used pixels + bool LockDisableResize; // Disable resizing texture + bool PreloadedAllGlyphsRanges; // Set when missing ImGuiBackendFlags_RendererHasTextures features forces atlas to preload everything. + + // Cache of all ImFontBaked + ImStableVector_ImFontBaked_32 BakedPool; + ImGuiStorage BakedMap; // BakedId --> ImFontBaked* + int BakedDiscardedCount; + + // Custom rectangle identifiers + ImFontAtlasRectId PackIdMouseCursors; // White pixel + mouse cursors. Also happen to be fallback in case of packing failure. + ImFontAtlasRectId PackIdLinesTexData; +}; + +CIMGUI_API void cImFontAtlasBuildInit(ImFontAtlas* atlas); +CIMGUI_API void cImFontAtlasBuildDestroy(ImFontAtlas* atlas); +CIMGUI_API void cImFontAtlasBuildMain(ImFontAtlas* atlas); +CIMGUI_API void cImFontAtlasBuildSetupFontLoader(ImFontAtlas* atlas, const ImFontLoader* font_loader); +CIMGUI_API void cImFontAtlasBuildUpdatePointers(ImFontAtlas* atlas); +CIMGUI_API void cImFontAtlasBuildRenderBitmapFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char); +CIMGUI_API void cImFontAtlasBuildClear(ImFontAtlas* atlas); // Clear output and custom rects + +CIMGUI_API ImTextureData* cImFontAtlasTextureAdd(ImFontAtlas* atlas, int w, int h); +CIMGUI_API void cImFontAtlasTextureMakeSpace(ImFontAtlas* atlas); +CIMGUI_API void cImFontAtlasTextureRepack(ImFontAtlas* atlas, int w, int h); +CIMGUI_API void cImFontAtlasTextureGrow(ImFontAtlas* atlas); // Implied old_w = -1, old_h = -1 +CIMGUI_API void cImFontAtlasTextureGrowEx(ImFontAtlas* atlas, int old_w /* = -1 */, int old_h /* = -1 */); +CIMGUI_API void cImFontAtlasTextureCompact(ImFontAtlas* atlas); +CIMGUI_API ImVec2i cImFontAtlasTextureGetSizeEstimate(ImFontAtlas* atlas); + +CIMGUI_API void cImFontAtlasBuildSetupFontSpecialGlyphs(ImFontAtlas* atlas, ImFont* font, ImFontConfig* src); +CIMGUI_API void cImFontAtlasBuildLegacyPreloadAllGlyphRanges(ImFontAtlas* atlas); // Legacy +CIMGUI_API void cImFontAtlasBuildGetOversampleFactors(ImFontConfig* src, ImFontBaked* baked, int* out_oversample_h, int* out_oversample_v); +CIMGUI_API void cImFontAtlasBuildDiscardBakes(ImFontAtlas* atlas, int unused_frames); + +CIMGUI_API bool cImFontAtlasFontSourceInit(ImFontAtlas* atlas, ImFontConfig* src); +CIMGUI_API void cImFontAtlasFontSourceAddToFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* src); +CIMGUI_API void cImFontAtlasFontDestroySourceData(ImFontAtlas* atlas, ImFontConfig* src); +CIMGUI_API bool cImFontAtlasFontInitOutput(ImFontAtlas* atlas, ImFont* font); // Using FontDestroyOutput/FontInitOutput sequence useful notably if font loader params have changed +CIMGUI_API void cImFontAtlasFontDestroyOutput(ImFontAtlas* atlas, ImFont* font); +CIMGUI_API void cImFontAtlasFontDiscardBakes(ImFontAtlas* atlas, ImFont* font, int unused_frames); + +CIMGUI_API ImGuiID cImFontAtlasBakedGetId(ImGuiID font_id, float baked_size, float rasterizer_density); +CIMGUI_API ImFontBaked* cImFontAtlasBakedGetOrAdd(ImFontAtlas* atlas, ImFont* font, float font_size, float font_rasterizer_density); +CIMGUI_API ImFontBaked* cImFontAtlasBakedGetClosestMatch(ImFontAtlas* atlas, ImFont* font, float font_size, float font_rasterizer_density); +CIMGUI_API ImFontBaked* cImFontAtlasBakedAdd(ImFontAtlas* atlas, ImFont* font, float font_size, float font_rasterizer_density, ImGuiID baked_id); +CIMGUI_API void cImFontAtlasBakedDiscard(ImFontAtlas* atlas, ImFont* font, ImFontBaked* baked); +CIMGUI_API ImFontGlyph* cImFontAtlasBakedAddFontGlyph(ImFontAtlas* atlas, ImFontBaked* baked, ImFontConfig* src, const ImFontGlyph* in_glyph); +CIMGUI_API void cImFontAtlasBakedAddFontGlyphAdvancedX(ImFontAtlas* atlas, ImFontBaked* baked, ImFontConfig* src, ImWchar codepoint, float advance_x); +CIMGUI_API void cImFontAtlasBakedDiscardFontGlyph(ImFontAtlas* atlas, ImFont* font, ImFontBaked* baked, ImFontGlyph* glyph); +CIMGUI_API void cImFontAtlasBakedSetFontGlyphBitmap(ImFontAtlas* atlas, ImFontBaked* baked, ImFontConfig* src, ImFontGlyph* glyph, ImTextureRect* r, const unsigned char* src_pixels, ImTextureFormat src_fmt, int src_pitch); + +CIMGUI_API void cImFontAtlasPackInit(ImFontAtlas* atlas); +CIMGUI_API ImFontAtlasRectId cImFontAtlasPackAddRect(ImFontAtlas* atlas, int w, int h); // Implied overwrite_entry = NULL +CIMGUI_API ImFontAtlasRectId cImFontAtlasPackAddRectEx(ImFontAtlas* atlas, int w, int h, ImFontAtlasRectEntry* overwrite_entry /* = NULL */); +CIMGUI_API ImTextureRect* cImFontAtlasPackGetRect(ImFontAtlas* atlas, ImFontAtlasRectId id); +CIMGUI_API ImTextureRect* cImFontAtlasPackGetRectSafe(ImFontAtlas* atlas, ImFontAtlasRectId id); +CIMGUI_API void cImFontAtlasPackDiscardRect(ImFontAtlas* atlas, ImFontAtlasRectId id); + +CIMGUI_API void cImFontAtlasUpdateNewFrame(ImFontAtlas* atlas, int frame_count, bool renderer_has_textures); +CIMGUI_API void cImFontAtlasAddDrawListSharedData(ImFontAtlas* atlas, ImDrawListSharedData* data); +CIMGUI_API void cImFontAtlasRemoveDrawListSharedData(ImFontAtlas* atlas, ImDrawListSharedData* data); +CIMGUI_API void cImFontAtlasUpdateDrawListsTextures(ImFontAtlas* atlas, ImTextureRef old_tex, ImTextureRef new_tex); +CIMGUI_API void cImFontAtlasUpdateDrawListsSharedData(ImFontAtlas* atlas); + +CIMGUI_API void cImFontAtlasTextureBlockConvert(const unsigned char* src_pixels, ImTextureFormat src_fmt, int src_pitch, unsigned char* dst_pixels, ImTextureFormat dst_fmt, int dst_pitch, int w, int h); +CIMGUI_API void cImFontAtlasTextureBlockPostProcess(ImFontAtlasPostProcessData* data); +CIMGUI_API void cImFontAtlasTextureBlockPostProcessMultiply(ImFontAtlasPostProcessData* data, float multiply_factor); +CIMGUI_API void cImFontAtlasTextureBlockFill(ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h, ImU32 col); +CIMGUI_API void cImFontAtlasTextureBlockCopy(ImTextureData* src_tex, int src_x, int src_y, ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h); +CIMGUI_API void cImFontAtlasTextureBlockQueueUpload(ImFontAtlas* atlas, ImTextureData* tex, int x, int y, int w, int h); + +CIMGUI_API int cImTextureDataGetFormatBytesPerPixel(ImTextureFormat format); +CIMGUI_API const char* cImTextureDataGetStatusName(ImTextureStatus status); +CIMGUI_API const char* cImTextureDataGetFormatName(ImTextureFormat format); + +#ifndef IMGUI_DISABLE_DEBUG_TOOLS +CIMGUI_API void cImFontAtlasDebugLogTextureRequests(ImFontAtlas* atlas); +#endif // #ifndef IMGUI_DISABLE_DEBUG_TOOLS +CIMGUI_API bool cImFontAtlasGetMouseCursorTexData(ImFontAtlas* atlas, ImGuiMouseCursor cursor_type, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2]); + +//----------------------------------------------------------------------------- +// [SECTION] Test Engine specific hooks (imgui_test_engine) +//----------------------------------------------------------------------------- + +#ifdef IMGUI_ENABLE_TEST_ENGINE +extern +CIMGUI_API void cImGuiTestEngineHook_ItemAdd(ImGuiContext* ctx, ImGuiID id, ImRect bb, const ImGuiLastItemData* item_data); // item_data may be NULL +extern +CIMGUI_API void cImGuiTestEngineHook_ItemInfo(ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags); +extern +CIMGUI_API void cImGuiTestEngineHook_Log(ImGuiContext* ctx, const char* fmt, ...); +extern +CIMGUI_API const char* cImGuiTestEngine_FindItemDebugLabel(ImGuiContext* ctx, ImGuiID id); + +// In IMGUI_VERSION_NUM >= 18934: changed IMGUI_TEST_ENGINE_ITEM_ADD(bb,id) to IMGUI_TEST_ENGINE_ITEM_ADD(id,bb,item_data); +#define IMGUI_TEST_ENGINE_ITEM_ADD(_ID,_BB,_ITEM_DATA) if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemAdd(&g, _ID, _BB, _ITEM_DATA) // Register item bounding box +#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) +#define IMGUI_TEST_ENGINE_LOG(_FMT,...) ImGuiTestEngineHook_Log(&g, _FMT, __VA_ARGS__) // Custom log entry from user land into test log +#else +#define IMGUI_TEST_ENGINE_ITEM_ADD(_BB,_ID) ((void)0) +#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS) ((void)g) +#endif // #ifdef IMGUI_ENABLE_TEST_ENGINE +//----------------------------------------------------------------------------- + +#if defined(__clang__) +#pragma clang diagnostic pop +#else +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif // #if defined(__GNUC__) +#endif // #if defined(__clang__) +#ifdef _MSC_VER +#pragma warning (pop) +#endif // #ifdef _MSC_VER +#endif// #ifndef IMGUI_DISABLE +#ifdef __cplusplus +} // End of extern "C" block +#endif diff --git a/src/cached/dcimgui_internal.json b/src/cached/dcimgui_internal.json new file mode 100644 index 0000000..908c6ef --- /dev/null +++ b/src/cached/dcimgui_internal.json @@ -0,0 +1,81831 @@ +{ + "defines": [ + { + "name": "IMGUI_ENABLE_SSE", + "conditionals": [ + { + "condition": "if", + "expression": "(defined __SSE__ || defined __x86_64__ || defined _M_X64 ||(defined(_M_IX86_FP)&&(_M_IX86_FP >= 1)))&&!defined(IMGUI_DISABLE_SSE)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 64 + } + }, + { + "name": "IMGUI_ENABLE_SSE4_2", + "conditionals": [ + { + "condition": "if", + "expression": "(defined __SSE__ || defined __x86_64__ || defined _M_X64 ||(defined(_M_IX86_FP)&&(_M_IX86_FP >= 1)))&&!defined(IMGUI_DISABLE_SSE)" + }, + { + "condition": "if", + "expression": "(defined __AVX__ || defined __SSE4_2__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 67 + } + }, + { + "name": "IMGUI_ENABLE_SSE4_2_CRC", + "conditionals": [ + { + "condition": "if", + "expression": "defined(IMGUI_ENABLE_SSE4_2)&&!defined(IMGUI_USE_LEGACY_CRC32_ADLER)&&!defined(__EMSCRIPTEN__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 73 + } + }, + { + "name": "IMGUI_ENABLE_STB_TRUETYPE", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_ENABLE_FREETYPE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 128 + } + }, + { + "name": "IMGUI_PAYLOAD_TYPE_WINDOW", + "content": "\"_IMWINDOW\"", + "comments": { + "attached": "// Payload == ImGuiWindow*" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 237 + } + }, + { + "name": "IM_PI", + "content": "3.14159265358979323846f", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 276 + } + }, + { + "name": "IM_NEWLINE", + "content": "\"\\r\\n\"", + "comments": { + "attached": "// Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "_WIN32" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 278 + } + }, + { + "name": "IM_NEWLINE", + "content": "\"\\n\"", + "conditionals": [ + { + "condition": "ifndef", + "expression": "_WIN32" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 280 + } + }, + { + "name": "IM_TABSIZE", + "content": "4", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_TABSIZE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 283 + } + }, + { + "name": "IM_FLOOR", + "content": "IM_TRUNC", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 293 + } + }, + { + "name": "IM_LIKELY", + "content": "[[likely]]", + "conditionals": [ + { + "condition": "if", + "expression": "(defined(__cplusplus)&&(__cplusplus >= 202002L))||(defined(_MSVC_LANG)&&(_MSVC_LANG >= 202002L))" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 298 + } + }, + { + "name": "IM_UNLIKELY", + "content": "[[unlikely]]", + "conditionals": [ + { + "condition": "if", + "expression": "(defined(__cplusplus)&&(__cplusplus >= 202002L))||(defined(_MSVC_LANG)&&(_MSVC_LANG >= 202002L))" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 299 + } + }, + { + "name": "IM_LIKELY", + "conditionals": [ + { + "condition": "ifnot", + "expression": "(defined(__cplusplus)&&(__cplusplus >= 202002L))||(defined(_MSVC_LANG)&&(_MSVC_LANG >= 202002L))" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 301 + } + }, + { + "name": "IM_UNLIKELY", + "conditionals": [ + { + "condition": "ifnot", + "expression": "(defined(__cplusplus)&&(__cplusplus >= 202002L))||(defined(_MSVC_LANG)&&(_MSVC_LANG >= 202002L))" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 302 + } + }, + { + "name": "IMGUI_CDECL", + "content": "__cdecl", + "conditionals": [ + { + "condition": "ifdef", + "expression": "_MSC_VER" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 307 + } + }, + { + "name": "IMGUI_CDECL", + "conditionals": [ + { + "condition": "ifndef", + "expression": "_MSC_VER" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 309 + } + }, + { + "name": "IM_PRId64", + "content": "\"I64d\"", + "conditionals": [ + { + "condition": "if", + "expression": "defined(_MSC_VER)&&!defined(__clang__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 341 + } + }, + { + "name": "IM_PRIu64", + "content": "\"I64u\"", + "conditionals": [ + { + "condition": "if", + "expression": "defined(_MSC_VER)&&!defined(__clang__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 342 + } + }, + { + "name": "IM_PRIX64", + "content": "\"I64X\"", + "conditionals": [ + { + "condition": "if", + "expression": "defined(_MSC_VER)&&!defined(__clang__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 343 + } + }, + { + "name": "IM_PRId64", + "content": "\"lld\"", + "conditionals": [ + { + "condition": "ifnot", + "expression": "defined(_MSC_VER)&&!defined(__clang__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 345 + } + }, + { + "name": "IM_PRIu64", + "content": "\"llu\"", + "conditionals": [ + { + "condition": "ifnot", + "expression": "defined(_MSC_VER)&&!defined(__clang__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 346 + } + }, + { + "name": "IM_PRIX64", + "content": "\"llX\"", + "conditionals": [ + { + "condition": "ifnot", + "expression": "defined(_MSC_VER)&&!defined(__clang__)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 347 + } + }, + { + "name": "ImStrlen", + "content": "strlen", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 396 + } + }, + { + "name": "ImMemchr", + "content": "memchr", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 397 + } + }, + { + "name": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 443 + } + }, + { + "name": "IMGUI_DISABLE_TTY_FUNCTIONS", + "comments": { + "attached": "// Can't use stdout, fflush if we are not using default file functions" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 459 + } + }, + { + "name": "IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN", + "content": "4", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 830 + } + }, + { + "name": "IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX", + "content": "512", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 831 + } + }, + { + "name": "IM_DRAWLIST_ARCFAST_TABLE_SIZE", + "content": "48", + "comments": { + "attached": "// Number of samples in lookup table." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_DRAWLIST_ARCFAST_TABLE_SIZE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 840 + } + }, + { + "name": "IM_DRAWLIST_ARCFAST_SAMPLE_MAX", + "content": "IM_DRAWLIST_ARCFAST_TABLE_SIZE", + "comments": { + "attached": "// Sample index _PathArcToFastEx() for 360 angle." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 842 + } + }, + { + "name": "IMSTB_TEXTEDIT_STRING", + "content": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1209 + } + }, + { + "name": "IMSTB_TEXTEDIT_CHARTYPE", + "content": "char", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1210 + } + }, + { + "name": "IMSTB_TEXTEDIT_GETWIDTH_NEWLINE", + "content": "-1.0f", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1211 + } + }, + { + "name": "IMSTB_TEXTEDIT_UNDOSTATECOUNT", + "content": "99", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1212 + } + }, + { + "name": "IMSTB_TEXTEDIT_UNDOCHARCOUNT", + "content": "999", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1213 + } + }, + { + "name": "ImGuiKey_LegacyNativeKey_BEGIN", + "content": "0", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1476 + } + }, + { + "name": "ImGuiKey_LegacyNativeKey_END", + "content": "512", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1477 + } + }, + { + "name": "ImGuiKey_Keyboard_BEGIN", + "content": "ImGuiKey_NamedKey_BEGIN", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1478 + } + }, + { + "name": "ImGuiKey_Keyboard_END", + "content": "ImGuiKey_GamepadStart", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1479 + } + }, + { + "name": "ImGuiKey_Gamepad_BEGIN", + "content": "ImGuiKey_GamepadStart", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1480 + } + }, + { + "name": "ImGuiKey_Gamepad_END", + "content": "ImGuiKey_GamepadRStickDown + 1", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1481 + } + }, + { + "name": "ImGuiKey_Mouse_BEGIN", + "content": "ImGuiKey_MouseLeft", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1482 + } + }, + { + "name": "ImGuiKey_Mouse_END", + "content": "ImGuiKey_MouseWheelY + 1", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1483 + } + }, + { + "name": "ImGuiKey_Aliases_BEGIN", + "content": "ImGuiKey_Mouse_BEGIN", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1484 + } + }, + { + "name": "ImGuiKey_Aliases_END", + "content": "ImGuiKey_Mouse_END", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1485 + } + }, + { + "name": "ImGuiKey_NavKeyboardTweakSlow", + "content": "ImGuiMod_Ctrl", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1488 + } + }, + { + "name": "ImGuiKey_NavKeyboardTweakFast", + "content": "ImGuiMod_Shift", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1489 + } + }, + { + "name": "ImGuiKey_NavGamepadTweakSlow", + "content": "ImGuiKey_GamepadL1", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1490 + } + }, + { + "name": "ImGuiKey_NavGamepadTweakFast", + "content": "ImGuiKey_GamepadR1", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1491 + } + }, + { + "name": "ImGuiKey_NavGamepadActivate", + "content": "g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceRight : ImGuiKey_GamepadFaceDown", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1492 + } + }, + { + "name": "ImGuiKey_NavGamepadCancel", + "content": "g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceDown : ImGuiKey_GamepadFaceRight", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1493 + } + }, + { + "name": "ImGuiKey_NavGamepadMenu", + "content": "ImGuiKey_GamepadFaceLeft", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1494 + } + }, + { + "name": "ImGuiKey_NavGamepadInput", + "content": "ImGuiKey_GamepadFaceUp", + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1495 + } + }, + { + "name": "ImGuiKeyOwner_Any", + "content": "(ImGuiID)0", + "comments": { + "attached": "// Accept key that have an owner, UNLESS a call to SetKeyOwner() explicitly used ImGuiInputFlags_LockThisFrame or ImGuiInputFlags_LockUntilRelease." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1550 + } + }, + { + "name": "ImGuiKeyOwner_NoOwner", + "content": "(ImGuiID)-1", + "comments": { + "attached": "// Require key to have no owner." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1551 + } + }, + { + "name": "ImGuiSelectionUserData_Invalid", + "content": "(ImGuiSelectionUserData)-1", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1888 + } + }, + { + "name": "DOCKING_HOST_DRAW_CHANNEL_BG", + "content": "0", + "comments": { + "attached": "// Dock host: background fill" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1934 + } + }, + { + "name": "DOCKING_HOST_DRAW_CHANNEL_FG", + "content": "1", + "comments": { + "attached": "// Dock host: decorations and contents" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1935 + } + }, + { + "name": "IM_COL32_DISABLE", + "content": "IM_COL32(0,0,0,1)", + "comments": { + "attached": "// Special sentinel code which cannot be used as a regular color." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3029 + } + }, + { + "name": "IMGUI_TABLE_MAX_COLUMNS", + "content": "512", + "comments": { + "attached": "// Arbitrary \"safety\" maximum, may be lifted in the future if needed. Must fit in ImGuiTableColumnIdx/ImGuiTableDrawChannelIdx." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3030 + } + }, + { + "name": "IMGUI_FONT_SIZE_MAX", + "content": "512.0f", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4024 + } + }, + { + "name": "IMGUI_FONT_SIZE_THRESHOLD_FOR_LOADADVANCEXONLYMODE", + "content": "128.0f", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4025 + } + }, + { + "name": "ImFontAtlasRectId_IndexMask_", + "content": "0x000FFFFF", + "comments": { + "attached": "// 20-bits: index to access builder->RectsIndex[]." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4033 + } + }, + { + "name": "ImFontAtlasRectId_GenerationMask_", + "content": "0x3FF00000", + "comments": { + "attached": "// 10-bits: entry generation, so each ID is unique and get can safely detected old identifiers." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4034 + } + }, + { + "name": "ImFontAtlasRectId_GenerationShift_", + "content": "20", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4035 + } + } + ], + "enums": [ + { + "name": "ImGuiDataTypePrivate_", + "original_fully_qualified_name": "ImGuiDataTypePrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiDataType_Pointer", + "value_expression": "ImGuiDataType_COUNT", + "value": 12, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 940 + } + }, + { + "name": "ImGuiDataType_ID", + "value": 13, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 941 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiDataType_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 938 + } + }, + { + "name": "ImGuiItemFlagsPrivate_", + "original_fully_qualified_name": "ImGuiItemFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiItemFlags_Disabled", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "preceding": [ + "// Controlled by user" + ], + "attached": "// false // Disable interactions (DOES NOT affect visuals. DO NOT mix direct use of this with BeginDisabled(). See BeginDisabled()/EndDisabled() for full disable feature, and github #211)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 954 + } + }, + { + "name": "ImGuiItemFlags_ReadOnly", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// false // [ALPHA] Allow hovering interactions but underlying value is not changed." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 955 + } + }, + { + "name": "ImGuiItemFlags_MixedValue", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// false // [BETA] Represent a mixed/indeterminate value, generally multi-selection where values differ. Currently only supported by Checkbox() (later should support all sorts of widgets)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 956 + } + }, + { + "name": "ImGuiItemFlags_NoWindowHoverableCheck", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// false // Disable hoverable check in ItemHoverable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 957 + } + }, + { + "name": "ImGuiItemFlags_AllowOverlap", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// false // Allow being overlapped by another widget. Not-hovered to Hovered transition deferred by a frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 958 + } + }, + { + "name": "ImGuiItemFlags_NoNavDisableMouseHover", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// false // Nav keyboard/gamepad mode doesn't disable hover highlight (behave as if NavHighlightItemUnderNav==false)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 959 + } + }, + { + "name": "ImGuiItemFlags_NoMarkEdited", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// false // Skip calling MarkItemEdited()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 960 + } + }, + { + "name": "ImGuiItemFlags_NoFocus", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// false // [EXPERIMENTAL: Not very well specced] Clicking doesn't take focus. Automatically sets ImGuiButtonFlags_NoFocus + ImGuiButtonFlags_NoNavFocus in ButtonBehavior()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 961 + } + }, + { + "name": "ImGuiItemFlags_Inputable", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "preceding": [ + "// Controlled by widget code" + ], + "attached": "// false // [WIP] Auto-activate input mode when tab focused. Currently only used and supported by a few items before it becomes a generic feature." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 964 + } + }, + { + "name": "ImGuiItemFlags_HasSelectionUserData", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// false // Set by SetNextItemSelectionUserData()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 965 + } + }, + { + "name": "ImGuiItemFlags_IsMultiSelect", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// false // Set by SetNextItemSelectionUserData()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 966 + } + }, + { + "name": "ImGuiItemFlags_Default_", + "value_expression": "ImGuiItemFlags_AutoClosePopups", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Please don't change, use PushItemFlag() instead." + }, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 968 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiItemFlags", + "// - input: PushItemFlag() manipulates g.CurrentItemFlags, g.NextItemData.ItemFlags, ItemAdd() calls may add extra flags too.", + "// - output: stored in g.LastItemData.ItemFlags" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 951 + } + }, + { + "name": "ImGuiItemStatusFlags_", + "original_fully_qualified_name": "ImGuiItemStatusFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiItemStatusFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 978 + } + }, + { + "name": "ImGuiItemStatusFlags_HoveredRect", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Mouse position is within item rectangle (does NOT mean that the window is in correct z-order and can be hovered!, this is only one part of the most-common IsItemHovered test)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 979 + } + }, + { + "name": "ImGuiItemStatusFlags_HasDisplayRect", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// g.LastItemData.DisplayRect is valid" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 980 + } + }, + { + "name": "ImGuiItemStatusFlags_Edited", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Value exposed by item was edited in the current frame (should match the bool return value of most widgets)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 981 + } + }, + { + "name": "ImGuiItemStatusFlags_ToggledSelection", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Set when Selectable(), TreeNode() reports toggling a selection. We can't report \"Selected\", only state changes, in order to easily handle clipping with less issues." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 982 + } + }, + { + "name": "ImGuiItemStatusFlags_ToggledOpen", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Set when TreeNode() reports toggling their open state." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 983 + } + }, + { + "name": "ImGuiItemStatusFlags_HasDeactivated", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 984 + } + }, + { + "name": "ImGuiItemStatusFlags_Deactivated", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Only valid if ImGuiItemStatusFlags_HasDeactivated is set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 985 + } + }, + { + "name": "ImGuiItemStatusFlags_HoveredWindow", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Override the HoveredWindow test to allow cross-window hover testing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 986 + } + }, + { + "name": "ImGuiItemStatusFlags_Visible", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// [WIP] Set when item is overlapping the current clipping rectangle (Used internally. Please don't use yet: API/system will change as we refactor Itemadd())." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 987 + } + }, + { + "name": "ImGuiItemStatusFlags_HasClipRect", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// g.LastItemData.ClipRect is valid." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 988 + } + }, + { + "name": "ImGuiItemStatusFlags_HasShortcut", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// g.LastItemData.Shortcut valid. Set by SetNextItemShortcut() -> ItemAdd()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 989 + } + }, + { + "name": "ImGuiItemStatusFlags_Openable", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// Item is an openable (e.g. TreeNode)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 994 + } + }, + { + "name": "ImGuiItemStatusFlags_Opened", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// Opened status" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 995 + } + }, + { + "name": "ImGuiItemStatusFlags_Checkable", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// Item is a checkable (e.g. CheckBox, MenuItem)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 996 + } + }, + { + "name": "ImGuiItemStatusFlags_Checked", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "attached": "// Checked status" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 997 + } + }, + { + "name": "ImGuiItemStatusFlags_Inputable", + "value_expression": "1<<24", + "value": 16777216, + "is_count": false, + "comments": { + "attached": "// Item is a text-inputable (e.g. InputText, SliderXXX, DragXXX)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 998 + } + } + ], + "comments": { + "preceding": [ + "// Status flags for an already submitted item", + "// - output: stored in g.LastItemData.StatusFlags" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 976 + } + }, + { + "name": "ImGuiHoveredFlagsPrivate_", + "original_fully_qualified_name": "ImGuiHoveredFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiHoveredFlags_DelayMask_", + "value_expression": "ImGuiHoveredFlags_DelayNone | ImGuiHoveredFlags_DelayShort | ImGuiHoveredFlags_DelayNormal | ImGuiHoveredFlags_NoSharedDelay", + "value": 245760, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1005 + } + }, + { + "name": "ImGuiHoveredFlags_AllowedMaskForIsWindowHovered", + "value_expression": "ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_NoPopupHierarchy | ImGuiHoveredFlags_DockHierarchy | ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary", + "value": 12479, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1006 + } + }, + { + "name": "ImGuiHoveredFlags_AllowedMaskForIsItemHovered", + "value_expression": "ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayMask_", + "value": 262048, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1007 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiHoveredFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1003 + } + }, + { + "name": "ImGuiInputTextFlagsPrivate_", + "original_fully_qualified_name": "ImGuiInputTextFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiInputTextFlags_Multiline", + "value_expression": "1<<26", + "value": 67108864, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal]" + ], + "attached": "// For internal use by InputTextMultiline()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1014 + } + }, + { + "name": "ImGuiInputTextFlags_MergedItem", + "value_expression": "1<<27", + "value": 134217728, + "is_count": false, + "comments": { + "attached": "// For internal use by TempInputText(), will skip calling ItemAdd(). Require bounding-box to strictly match." + }, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1015 + } + }, + { + "name": "ImGuiInputTextFlags_LocalizeDecimalPoint", + "value_expression": "1<<28", + "value": 268435456, + "is_count": false, + "comments": { + "attached": "// For internal use by InputScalar() and TempInputScalar()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1016 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiInputTextFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1011 + } + }, + { + "name": "ImGuiButtonFlagsPrivate_", + "original_fully_qualified_name": "ImGuiButtonFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiButtonFlags_PressedOnClick", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// return true on click (mouse down event)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1022 + } + }, + { + "name": "ImGuiButtonFlags_PressedOnClickRelease", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// [Default] return true on click + release on same item <-- this is what the majority of Button are using" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1023 + } + }, + { + "name": "ImGuiButtonFlags_PressedOnClickReleaseAnywhere", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// return true on click + release even if the release event is not done while hovering the item" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1024 + } + }, + { + "name": "ImGuiButtonFlags_PressedOnRelease", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// return true on release (default requires click+release)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1025 + } + }, + { + "name": "ImGuiButtonFlags_PressedOnDoubleClick", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// return true on double-click (default requires click+release)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1026 + } + }, + { + "name": "ImGuiButtonFlags_PressedOnDragDropHold", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// return true when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1027 + } + }, + { + "name": "ImGuiButtonFlags_FlattenChildren", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "preceding": [ + "//ImGuiButtonFlags_Repeat = 1 << 10, // hold to repeat -> use ImGuiItemFlags_ButtonRepeat instead." + ], + "attached": "// allow interactions even if a child window is overlapping" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1029 + } + }, + { + "name": "ImGuiButtonFlags_AllowOverlap", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// require previous frame HoveredId to either match id or be null before being usable." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1030 + } + }, + { + "name": "ImGuiButtonFlags_AlignTextBaseLine", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "preceding": [ + "//ImGuiButtonFlags_DontClosePopups = 1 << 13, // disable automatically closing parent popup on press", + "//ImGuiButtonFlags_Disabled = 1 << 14, // disable interactions -> use BeginDisabled() or ImGuiItemFlags_Disabled" + ], + "attached": "// vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1033 + } + }, + { + "name": "ImGuiButtonFlags_NoKeyModsAllowed", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// disable mouse interaction if a key modifier is held" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1034 + } + }, + { + "name": "ImGuiButtonFlags_NoHoldingActiveId", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1035 + } + }, + { + "name": "ImGuiButtonFlags_NoNavFocus", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "attached": "// don't override navigation focus when activated (FIXME: this is essentially used every time an item uses ImGuiItemFlags_NoNav, but because legacy specs don't requires LastItemData to be set ButtonBehavior(), we can't poll g.LastItemData.ItemFlags)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1036 + } + }, + { + "name": "ImGuiButtonFlags_NoHoveredOnFocus", + "value_expression": "1<<19", + "value": 524288, + "is_count": false, + "comments": { + "attached": "// don't report as hovered when nav focus is on this item" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1037 + } + }, + { + "name": "ImGuiButtonFlags_NoSetKeyOwner", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1038 + } + }, + { + "name": "ImGuiButtonFlags_NoTestKeyOwner", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// don't test key/input owner when polling the key (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1039 + } + }, + { + "name": "ImGuiButtonFlags_NoFocus", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// [EXPERIMENTAL: Not very well specced]. Don't focus parent window when clicking." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1040 + } + }, + { + "name": "ImGuiButtonFlags_PressedOnMask_", + "value_expression": "ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_PressedOnDragDropHold", + "value": 1008, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1041 + } + }, + { + "name": "ImGuiButtonFlags_PressedOnDefault_", + "value_expression": "ImGuiButtonFlags_PressedOnClickRelease", + "value": 32, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1042 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiButtonFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1020 + } + }, + { + "name": "ImGuiComboFlagsPrivate_", + "original_fully_qualified_name": "ImGuiComboFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiComboFlags_CustomPreview", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// enable BeginComboPreview()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1049 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiComboFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1047 + } + }, + { + "name": "ImGuiSliderFlagsPrivate_", + "original_fully_qualified_name": "ImGuiSliderFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiSliderFlags_Vertical", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// Should this slider be orientated vertically?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1055 + } + }, + { + "name": "ImGuiSliderFlags_ReadOnly", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// Consider using g.NextItemData.ItemFlags |= ImGuiItemFlags_ReadOnly instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1056 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiSliderFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1053 + } + }, + { + "name": "ImGuiSelectableFlagsPrivate_", + "original_fully_qualified_name": "ImGuiSelectableFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiSelectableFlags_NoHoldingActiveID", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "preceding": [ + "// NB: need to be in sync with last value of ImGuiSelectableFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1063 + } + }, + { + "name": "ImGuiSelectableFlags_SelectOnNav", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// (WIP) Auto-select when moved into. This is not exposed in public API as to handle multi-select and modifiers we will need user to explicitly control focus scope. May be replaced with a BeginSelection() API." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1064 + } + }, + { + "name": "ImGuiSelectableFlags_SelectOnClick", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// Override button behavior to react on Click (default is Click+Release)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1065 + } + }, + { + "name": "ImGuiSelectableFlags_SelectOnRelease", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "attached": "// Override button behavior to react on Release (default is Click+Release)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1066 + } + }, + { + "name": "ImGuiSelectableFlags_SpanAvailWidth", + "value_expression": "1<<24", + "value": 16777216, + "is_count": false, + "comments": { + "attached": "// Span all avail width even if we declared less for layout purpose. FIXME: We may be able to remove this (added in 6251d379, 2bcafc86 for menus)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1067 + } + }, + { + "name": "ImGuiSelectableFlags_SetNavIdOnHover", + "value_expression": "1<<25", + "value": 33554432, + "is_count": false, + "comments": { + "attached": "// Set Nav/Focus ID on mouse hover (used by MenuItem)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1068 + } + }, + { + "name": "ImGuiSelectableFlags_NoPadWithHalfSpacing", + "value_expression": "1<<26", + "value": 67108864, + "is_count": false, + "comments": { + "attached": "// Disable padding each side with ItemSpacing * 0.5f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1069 + } + }, + { + "name": "ImGuiSelectableFlags_NoSetKeyOwner", + "value_expression": "1<<27", + "value": 134217728, + "is_count": false, + "comments": { + "attached": "// Don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1070 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiSelectableFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1060 + } + }, + { + "name": "ImGuiTreeNodeFlagsPrivate_", + "original_fully_qualified_name": "ImGuiTreeNodeFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiTreeNodeFlags_NoNavFocus", + "value_expression": "1<<27", + "value": 134217728, + "is_count": false, + "comments": { + "attached": "// Don't claim nav focus when interacting with this item (#8551)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1076 + } + }, + { + "name": "ImGuiTreeNodeFlags_ClipLabelForTrailingButton", + "value_expression": "1<<28", + "value": 268435456, + "is_count": false, + "comments": { + "attached": "// FIXME-WIP: Hard-coded for CollapsingHeader()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1077 + } + }, + { + "name": "ImGuiTreeNodeFlags_UpsideDownArrow", + "value_expression": "1<<29", + "value": 536870912, + "is_count": false, + "comments": { + "attached": "// FIXME-WIP: Turn Down arrow into an Up arrow, for reversed trees (#6517)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1078 + } + }, + { + "name": "ImGuiTreeNodeFlags_OpenOnMask_", + "value_expression": "ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_OpenOnArrow", + "value": 192, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1079 + } + }, + { + "name": "ImGuiTreeNodeFlags_DrawLinesMask_", + "value_expression": "ImGuiTreeNodeFlags_DrawLinesNone | ImGuiTreeNodeFlags_DrawLinesFull | ImGuiTreeNodeFlags_DrawLinesToNodes", + "value": 1835008, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1080 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiTreeNodeFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1074 + } + }, + { + "name": "ImGuiSeparatorFlags_", + "original_fully_qualified_name": "ImGuiSeparatorFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiSeparatorFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1085 + } + }, + { + "name": "ImGuiSeparatorFlags_Horizontal", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1086 + } + }, + { + "name": "ImGuiSeparatorFlags_Vertical", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1087 + } + }, + { + "name": "ImGuiSeparatorFlags_SpanAllColumns", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Make separator cover all columns of a legacy Columns() set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1088 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1083 + } + }, + { + "name": "ImGuiFocusRequestFlags_", + "original_fully_qualified_name": "ImGuiFocusRequestFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiFocusRequestFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1096 + } + }, + { + "name": "ImGuiFocusRequestFlags_RestoreFocusedChild", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Find last focused child (if any) and focus it instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1097 + } + }, + { + "name": "ImGuiFocusRequestFlags_UnlessBelowModal", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Do not set focus if the window is below a modal." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1098 + } + } + ], + "comments": { + "preceding": [ + "// Flags for FocusWindow(). This is not called ImGuiFocusFlags to avoid confusion with public-facing ImGuiFocusedFlags.", + "// FIXME: Once we finishing replacing more uses of GetTopMostPopupModal()+IsWindowWithinBeginStackOf()", + "// and FindBlockingModal() with this, we may want to change the flag to be opt-out instead of opt-in." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1094 + } + }, + { + "name": "ImGuiTextFlags_", + "original_fully_qualified_name": "ImGuiTextFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTextFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1103 + } + }, + { + "name": "ImGuiTextFlags_NoWidthForLargeClippedText", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1104 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1101 + } + }, + { + "name": "ImGuiTooltipFlags_", + "original_fully_qualified_name": "ImGuiTooltipFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTooltipFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1109 + } + }, + { + "name": "ImGuiTooltipFlags_OverridePrevious", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Clear/ignore previously submitted tooltip (defaults to append)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1110 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1107 + } + }, + { + "name": "ImGuiLayoutType_", + "original_fully_qualified_name": "ImGuiLayoutType_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiLayoutType_Horizontal", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1117 + } + }, + { + "name": "ImGuiLayoutType_Vertical", + "value_expression": "1", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1118 + } + } + ], + "comments": { + "preceding": [ + "// FIXME: this is in development, not exposed/functional as a generic feature yet.", + "// Horizontal/Vertical enums are fixed to 0/1 so they may be used to index ImVec2" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1115 + } + }, + { + "name": "ImGuiLogFlags_", + "original_fully_qualified_name": "ImGuiLogFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiLogFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1124 + } + }, + { + "name": "ImGuiLogFlags_OutputTTY", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1126 + } + }, + { + "name": "ImGuiLogFlags_OutputFile", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1127 + } + }, + { + "name": "ImGuiLogFlags_OutputBuffer", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1128 + } + }, + { + "name": "ImGuiLogFlags_OutputClipboard", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1129 + } + }, + { + "name": "ImGuiLogFlags_OutputMask_", + "value_expression": "ImGuiLogFlags_OutputTTY | ImGuiLogFlags_OutputFile | ImGuiLogFlags_OutputBuffer | ImGuiLogFlags_OutputClipboard", + "value": 15, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1130 + } + } + ], + "comments": { + "preceding": [ + "// Flags for LogBegin() text capturing function" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1122 + } + }, + { + "name": "ImGuiAxis", + "original_fully_qualified_name": "ImGuiAxis", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiAxis_None", + "value_expression": "-1", + "value": -1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1136 + } + }, + { + "name": "ImGuiAxis_X", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1137 + } + }, + { + "name": "ImGuiAxis_Y", + "value_expression": "1", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1138 + } + } + ], + "comments": { + "preceding": [ + "// X/Y enums are fixed to 0/1 so they may be used to index ImVec2" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1134 + } + }, + { + "name": "ImGuiPlotType", + "original_fully_qualified_name": "ImGuiPlotType", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiPlotType_Lines", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1143 + } + }, + { + "name": "ImGuiPlotType_Histogram", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1144 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1141 + } + }, + { + "name": "ImGuiWindowRefreshFlags_", + "original_fully_qualified_name": "ImGuiWindowRefreshFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiWindowRefreshFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1269 + } + }, + { + "name": "ImGuiWindowRefreshFlags_TryToAvoidRefresh", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// [EXPERIMENTAL] Try to keep existing contents, USER MUST NOT HONOR BEGIN() RETURNING FALSE AND NOT APPEND." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1270 + } + }, + { + "name": "ImGuiWindowRefreshFlags_RefreshOnHover", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// [EXPERIMENTAL] Always refresh on hover" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1271 + } + }, + { + "name": "ImGuiWindowRefreshFlags_RefreshOnFocus", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// [EXPERIMENTAL] Always refresh on focus" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1272 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1267 + } + }, + { + "name": "ImGuiNextWindowDataFlags_", + "original_fully_qualified_name": "ImGuiNextWindowDataFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiNextWindowDataFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1278 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasPos", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1279 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasSize", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1280 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasContentSize", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1281 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasCollapsed", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1282 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasSizeConstraint", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1283 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasFocus", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1284 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasBgAlpha", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1285 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasScroll", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1286 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasWindowFlags", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1287 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasChildFlags", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1288 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasRefreshPolicy", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1289 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasViewport", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1290 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasDock", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1291 + } + }, + { + "name": "ImGuiNextWindowDataFlags_HasWindowClass", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1292 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1276 + } + }, + { + "name": "ImGuiNextItemDataFlags_", + "original_fully_qualified_name": "ImGuiNextItemDataFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiNextItemDataFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1330 + } + }, + { + "name": "ImGuiNextItemDataFlags_HasWidth", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1331 + } + }, + { + "name": "ImGuiNextItemDataFlags_HasOpen", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1332 + } + }, + { + "name": "ImGuiNextItemDataFlags_HasShortcut", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1333 + } + }, + { + "name": "ImGuiNextItemDataFlags_HasRefVal", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1334 + } + }, + { + "name": "ImGuiNextItemDataFlags_HasStorageID", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1335 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1328 + } + }, + { + "name": "ImGuiPopupPositionPolicy", + "original_fully_qualified_name": "ImGuiPopupPositionPolicy", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiPopupPositionPolicy_Default", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1448 + } + }, + { + "name": "ImGuiPopupPositionPolicy_ComboBox", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1449 + } + }, + { + "name": "ImGuiPopupPositionPolicy_Tooltip", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1450 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1446 + } + }, + { + "name": "ImGuiInputEventType", + "original_fully_qualified_name": "ImGuiInputEventType", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiInputEventType_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1499 + } + }, + { + "name": "ImGuiInputEventType_MousePos", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1500 + } + }, + { + "name": "ImGuiInputEventType_MouseWheel", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1501 + } + }, + { + "name": "ImGuiInputEventType_MouseButton", + "value": 3, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1502 + } + }, + { + "name": "ImGuiInputEventType_MouseViewport", + "value": 4, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1503 + } + }, + { + "name": "ImGuiInputEventType_Key", + "value": 5, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1504 + } + }, + { + "name": "ImGuiInputEventType_Text", + "value": 6, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1505 + } + }, + { + "name": "ImGuiInputEventType_Focus", + "value": 7, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1506 + } + }, + { + "name": "ImGuiInputEventType_COUNT", + "value": 8, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1507 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1497 + } + }, + { + "name": "ImGuiInputSource", + "original_fully_qualified_name": "ImGuiInputSource", + "storage_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiInputSource_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1512 + } + }, + { + "name": "ImGuiInputSource_Mouse", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Note: may be Mouse or TouchScreen or Pen. See io.MouseSource to distinguish them." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1513 + } + }, + { + "name": "ImGuiInputSource_Keyboard", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1514 + } + }, + { + "name": "ImGuiInputSource_Gamepad", + "value": 3, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1515 + } + }, + { + "name": "ImGuiInputSource_COUNT", + "value": 4, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1516 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1510 + } + }, + { + "name": "ImGuiInputFlagsPrivate_", + "original_fully_qualified_name": "ImGuiInputFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiInputFlags_RepeatRateDefault", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "preceding": [ + "// Flags for IsKeyPressed(), IsKeyChordPressed(), IsMouseClicked(), Shortcut()", + "// - Repeat mode: Repeat rate selection" + ], + "attached": "// Repeat rate: Regular (default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1600 + } + }, + { + "name": "ImGuiInputFlags_RepeatRateNavMove", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Repeat rate: Fast" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1601 + } + }, + { + "name": "ImGuiInputFlags_RepeatRateNavTweak", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Repeat rate: Faster" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1602 + } + }, + { + "name": "ImGuiInputFlags_RepeatUntilRelease", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "preceding": [ + "// - Repeat mode: Specify when repeating key pressed can be interrupted.", + "// - In theory ImGuiInputFlags_RepeatUntilOtherKeyPress may be a desirable default, but it would break too many behavior so everything is opt-in." + ], + "attached": "// Stop repeating when released (default for all functions except Shortcut). This only exists to allow overriding Shortcut() default behavior." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1605 + } + }, + { + "name": "ImGuiInputFlags_RepeatUntilKeyModsChange", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Stop repeating when released OR if keyboard mods are changed (default for Shortcut)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1606 + } + }, + { + "name": "ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Stop repeating when released OR if keyboard mods are leaving the None state. Allows going from Mod+Key to Key by releasing Mod." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1607 + } + }, + { + "name": "ImGuiInputFlags_RepeatUntilOtherKeyPress", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Stop repeating when released OR if any other keyboard key is pressed during the repeat" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1608 + } + }, + { + "name": "ImGuiInputFlags_LockThisFrame", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "preceding": [ + "// Flags for SetKeyOwner(), SetItemKeyOwner()", + "// - Locking key away from non-input aware code. Locking is useful to make input-owner-aware code steal keys from non-input-owner-aware code. If all code is input-owner-aware locking would never be necessary." + ], + "attached": "// Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared at end of frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1612 + } + }, + { + "name": "ImGuiInputFlags_LockUntilRelease", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared when the key is released or at end of each frame if key is released." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1613 + } + }, + { + "name": "ImGuiInputFlags_CondHovered", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "preceding": [ + "// - Condition for SetItemKeyOwner()" + ], + "attached": "// Only set if item is hovered (default to both)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1616 + } + }, + { + "name": "ImGuiInputFlags_CondActive", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "attached": "// Only set if item is active (default to both)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1617 + } + }, + { + "name": "ImGuiInputFlags_CondDefault_", + "value_expression": "ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive", + "value": 12582912, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1618 + } + }, + { + "name": "ImGuiInputFlags_RepeatRateMask_", + "value_expression": "ImGuiInputFlags_RepeatRateDefault | ImGuiInputFlags_RepeatRateNavMove | ImGuiInputFlags_RepeatRateNavTweak", + "value": 14, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal] Mask of which function support which flags" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1621 + } + }, + { + "name": "ImGuiInputFlags_RepeatUntilMask_", + "value_expression": "ImGuiInputFlags_RepeatUntilRelease | ImGuiInputFlags_RepeatUntilKeyModsChange | ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone | ImGuiInputFlags_RepeatUntilOtherKeyPress", + "value": 240, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1622 + } + }, + { + "name": "ImGuiInputFlags_RepeatMask_", + "value_expression": "ImGuiInputFlags_Repeat | ImGuiInputFlags_RepeatRateMask_ | ImGuiInputFlags_RepeatUntilMask_", + "value": 255, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1623 + } + }, + { + "name": "ImGuiInputFlags_CondMask_", + "value_expression": "ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive", + "value": 12582912, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1624 + } + }, + { + "name": "ImGuiInputFlags_RouteTypeMask_", + "value_expression": "ImGuiInputFlags_RouteActive | ImGuiInputFlags_RouteFocused | ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteAlways", + "value": 15360, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1625 + } + }, + { + "name": "ImGuiInputFlags_RouteOptionsMask_", + "value_expression": "ImGuiInputFlags_RouteOverFocused | ImGuiInputFlags_RouteOverActive | ImGuiInputFlags_RouteUnlessBgFocused | ImGuiInputFlags_RouteFromRootWindow", + "value": 245760, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1626 + } + }, + { + "name": "ImGuiInputFlags_SupportedByIsKeyPressed", + "value_expression": "ImGuiInputFlags_RepeatMask_", + "value": 255, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1627 + } + }, + { + "name": "ImGuiInputFlags_SupportedByIsMouseClicked", + "value_expression": "ImGuiInputFlags_Repeat", + "value": 1, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1628 + } + }, + { + "name": "ImGuiInputFlags_SupportedByShortcut", + "value_expression": "ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_", + "value": 261375, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1629 + } + }, + { + "name": "ImGuiInputFlags_SupportedBySetNextItemShortcut", + "value_expression": "ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_ | ImGuiInputFlags_Tooltip", + "value": 523519, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1630 + } + }, + { + "name": "ImGuiInputFlags_SupportedBySetKeyOwner", + "value_expression": "ImGuiInputFlags_LockThisFrame | ImGuiInputFlags_LockUntilRelease", + "value": 3145728, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1631 + } + }, + { + "name": "ImGuiInputFlags_SupportedBySetItemKeyOwner", + "value_expression": "ImGuiInputFlags_SupportedBySetKeyOwner | ImGuiInputFlags_CondMask_", + "value": 15728640, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1632 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiInputFlags_", + "// Flags for extended versions of IsKeyPressed(), IsMouseClicked(), Shortcut(), SetKeyOwner(), SetItemKeyOwner()", + "// Don't mistake with ImGuiInputTextFlags! (which is for ImGui::InputText() function)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1596 + } + }, + { + "name": "ImGuiActivateFlags_", + "original_fully_qualified_name": "ImGuiActivateFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiActivateFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1671 + } + }, + { + "name": "ImGuiActivateFlags_PreferInput", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Favor activation that requires keyboard text input (e.g. for Slider/Drag). Default for Enter key." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1672 + } + }, + { + "name": "ImGuiActivateFlags_PreferTweak", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Favor activation for tweaking with arrows or gamepad (e.g. for Slider/Drag). Default for Space key and if keyboard is not used." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1673 + } + }, + { + "name": "ImGuiActivateFlags_TryToPreserveState", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Request widget to preserve state if it can (e.g. InputText will try to preserve cursor/selection)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1674 + } + }, + { + "name": "ImGuiActivateFlags_FromTabbing", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Activation requested by a tabbing request" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1675 + } + }, + { + "name": "ImGuiActivateFlags_FromShortcut", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Activation requested by an item shortcut via SetNextItemShortcut() function." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1676 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1669 + } + }, + { + "name": "ImGuiScrollFlags_", + "original_fully_qualified_name": "ImGuiScrollFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiScrollFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1682 + } + }, + { + "name": "ImGuiScrollFlags_KeepVisibleEdgeX", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// If item is not visible: scroll as little as possible on X axis to bring item back into view [default for X axis]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1683 + } + }, + { + "name": "ImGuiScrollFlags_KeepVisibleEdgeY", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// If item is not visible: scroll as little as possible on Y axis to bring item back into view [default for Y axis for windows that are already visible]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1684 + } + }, + { + "name": "ImGuiScrollFlags_KeepVisibleCenterX", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// If item is not visible: scroll to make the item centered on X axis [rarely used]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1685 + } + }, + { + "name": "ImGuiScrollFlags_KeepVisibleCenterY", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// If item is not visible: scroll to make the item centered on Y axis" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1686 + } + }, + { + "name": "ImGuiScrollFlags_AlwaysCenterX", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Always center the result item on X axis [rarely used]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1687 + } + }, + { + "name": "ImGuiScrollFlags_AlwaysCenterY", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Always center the result item on Y axis [default for Y axis for appearing window)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1688 + } + }, + { + "name": "ImGuiScrollFlags_NoScrollParent", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Disable forwarding scrolling to parent window if required to keep item/rect visible (only scroll window the function was applied to)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1689 + } + }, + { + "name": "ImGuiScrollFlags_MaskX_", + "value_expression": "ImGuiScrollFlags_KeepVisibleEdgeX | ImGuiScrollFlags_KeepVisibleCenterX | ImGuiScrollFlags_AlwaysCenterX", + "value": 21, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1690 + } + }, + { + "name": "ImGuiScrollFlags_MaskY_", + "value_expression": "ImGuiScrollFlags_KeepVisibleEdgeY | ImGuiScrollFlags_KeepVisibleCenterY | ImGuiScrollFlags_AlwaysCenterY", + "value": 42, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1691 + } + } + ], + "comments": { + "preceding": [ + "// Early work-in-progress API for ScrollToItem()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1680 + } + }, + { + "name": "ImGuiNavRenderCursorFlags_", + "original_fully_qualified_name": "ImGuiNavRenderCursorFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiNavRenderCursorFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1696 + } + }, + { + "name": "ImGuiNavRenderCursorFlags_Compact", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Compact highlight, no padding/distance from focused item" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1697 + } + }, + { + "name": "ImGuiNavRenderCursorFlags_AlwaysDraw", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Draw rectangular highlight if (g.NavId == id) even when g.NavCursorVisible == false, aka even when using the mouse." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1698 + } + }, + { + "name": "ImGuiNavRenderCursorFlags_NoRounding", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1699 + } + }, + { + "name": "ImGuiNavHighlightFlags_None", + "value_expression": "ImGuiNavRenderCursorFlags_None", + "value": 0, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.91.4" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1701 + } + }, + { + "name": "ImGuiNavHighlightFlags_Compact", + "value_expression": "ImGuiNavRenderCursorFlags_Compact", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.91.4" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1702 + } + }, + { + "name": "ImGuiNavHighlightFlags_AlwaysDraw", + "value_expression": "ImGuiNavRenderCursorFlags_AlwaysDraw", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.91.4" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1703 + } + }, + { + "name": "ImGuiNavHighlightFlags_NoRounding", + "value_expression": "ImGuiNavRenderCursorFlags_NoRounding", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.91.4" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1704 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1694 + } + }, + { + "name": "ImGuiNavMoveFlags_", + "original_fully_qualified_name": "ImGuiNavMoveFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiNavMoveFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1711 + } + }, + { + "name": "ImGuiNavMoveFlags_LoopX", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// On failed request, restart from opposite side" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1712 + } + }, + { + "name": "ImGuiNavMoveFlags_LoopY", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1713 + } + }, + { + "name": "ImGuiNavMoveFlags_WrapX", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1714 + } + }, + { + "name": "ImGuiNavMoveFlags_WrapY", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// This is not super useful but provided for completeness" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1715 + } + }, + { + "name": "ImGuiNavMoveFlags_WrapMask_", + "value_expression": "ImGuiNavMoveFlags_LoopX | ImGuiNavMoveFlags_LoopY | ImGuiNavMoveFlags_WrapX | ImGuiNavMoveFlags_WrapY", + "value": 15, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1716 + } + }, + { + "name": "ImGuiNavMoveFlags_AllowCurrentNavId", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Allow scoring and considering the current NavId as a move target candidate. This is used when the move source is offset (e.g. pressing PageDown actually needs to send a Up move request, if we are pressing PageDown from the bottom-most item we need to stay in place)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1717 + } + }, + { + "name": "ImGuiNavMoveFlags_AlsoScoreVisibleSet", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Store alternate result in NavMoveResultLocalVisible that only comprise elements that are already fully visible (used by PageUp/PageDown)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1718 + } + }, + { + "name": "ImGuiNavMoveFlags_ScrollToEdgeY", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Force scrolling to min/max (used by Home/End) // FIXME-NAV: Aim to remove or reword, probably unnecessary" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1719 + } + }, + { + "name": "ImGuiNavMoveFlags_Forwarded", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1720 + } + }, + { + "name": "ImGuiNavMoveFlags_DebugNoResult", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Dummy scoring for debug purpose, don't apply result" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1721 + } + }, + { + "name": "ImGuiNavMoveFlags_FocusApi", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Requests from focus API can land/focus/activate items even if they are marked with _NoTabStop (see NavProcessItemForTabbingRequest() for details)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1722 + } + }, + { + "name": "ImGuiNavMoveFlags_IsTabbing", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// == Focus + Activate if item is Inputable + DontChangeNavHighlight" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1723 + } + }, + { + "name": "ImGuiNavMoveFlags_IsPageMove", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Identify a PageDown/PageUp request." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1724 + } + }, + { + "name": "ImGuiNavMoveFlags_Activate", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Activate/select target item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1725 + } + }, + { + "name": "ImGuiNavMoveFlags_NoSelect", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Don't trigger selection by not setting g.NavJustMovedTo" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1726 + } + }, + { + "name": "ImGuiNavMoveFlags_NoSetNavCursorVisible", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Do not alter the nav cursor visible state" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1727 + } + }, + { + "name": "ImGuiNavMoveFlags_NoClearActiveId", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// (Experimental) Do not clear active id when applying move result" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1728 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1709 + } + }, + { + "name": "ImGuiNavLayer", + "original_fully_qualified_name": "ImGuiNavLayer", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiNavLayer_Main", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "attached": "// Main scrolling layer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1733 + } + }, + { + "name": "ImGuiNavLayer_Menu", + "value_expression": "1", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Menu layer (access with Alt)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1734 + } + }, + { + "name": "ImGuiNavLayer_COUNT", + "value": 2, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1735 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1731 + } + }, + { + "name": "ImGuiTypingSelectFlags_", + "original_fully_qualified_name": "ImGuiTypingSelectFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTypingSelectFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1769 + } + }, + { + "name": "ImGuiTypingSelectFlags_AllowBackspace", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Backspace to delete character inputs. If using: ensure GetTypingSelectRequest() is not called more than once per frame (filter by e.g. focus state)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1770 + } + }, + { + "name": "ImGuiTypingSelectFlags_AllowSingleCharMode", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Allow \"single char\" search mode which is activated when pressing the same character multiple times." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1771 + } + } + ], + "comments": { + "preceding": [ + "// Flags for GetTypingSelectRequest()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1767 + } + }, + { + "name": "ImGuiOldColumnFlags_", + "original_fully_qualified_name": "ImGuiOldColumnFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiOldColumnFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1806 + } + }, + { + "name": "ImGuiOldColumnFlags_NoBorder", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Disable column dividers" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1807 + } + }, + { + "name": "ImGuiOldColumnFlags_NoResize", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Disable resizing columns when clicking on the dividers" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1808 + } + }, + { + "name": "ImGuiOldColumnFlags_NoPreserveWidths", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Disable column width preservation when adjusting columns" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1809 + } + }, + { + "name": "ImGuiOldColumnFlags_NoForceWithinWindow", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Disable forcing columns to fit within window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1810 + } + }, + { + "name": "ImGuiOldColumnFlags_GrowParentContentsSize", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1811 + } + } + ], + "comments": { + "preceding": [ + "// Flags for internal's BeginColumns(). This is an obsolete API. Prefer using BeginTable() nowadays!" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1804 + } + }, + { + "name": "ImGuiDockNodeFlagsPrivate_", + "original_fully_qualified_name": "ImGuiDockNodeFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiDockNodeFlags_DockSpace", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal]" + ], + "attached": "// Saved // A dockspace is a node that occupy space within an existing user window. Otherwise the node is floating and create its own window." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1943 + } + }, + { + "name": "ImGuiDockNodeFlags_CentralNode", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Saved // The central node has 2 main properties: stay visible when empty, only use \"remaining\" spaces from its neighbor." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1944 + } + }, + { + "name": "ImGuiDockNodeFlags_NoTabBar", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Saved // Tab bar is completely unavailable. No triangle in the corner to enable it back." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1945 + } + }, + { + "name": "ImGuiDockNodeFlags_HiddenTabBar", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Saved // Tab bar is hidden, with a triangle in the corner to show it again (NB: actual tab-bar instance may be destroyed as this is only used for single-window tab bar)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1946 + } + }, + { + "name": "ImGuiDockNodeFlags_NoWindowMenuButton", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Saved // Disable window/docking menu (that one that appears instead of the collapse button)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1947 + } + }, + { + "name": "ImGuiDockNodeFlags_NoCloseButton", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Saved // Disable close button" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1948 + } + }, + { + "name": "ImGuiDockNodeFlags_NoResizeX", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// //" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1949 + } + }, + { + "name": "ImGuiDockNodeFlags_NoResizeY", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// //" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1950 + } + }, + { + "name": "ImGuiDockNodeFlags_DockedWindowsInFocusRoute", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "attached": "// // Any docked window will be automatically be focus-route chained (window->ParentWindowForFocusRoute set to this) so Shortcut() in this window can run when any docked window is focused." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1951 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDockingSplitOther", + "value_expression": "1<<19", + "value": 524288, + "is_count": false, + "comments": { + "preceding": [ + "// Disable docking/undocking actions in this dockspace or individual node (existing docked nodes will be preserved)", + "// Those are not exposed in public because the desirable sharing/inheriting/copy-flag-on-split behaviors are quite difficult to design and understand.", + "// The two public flags ImGuiDockNodeFlags_NoDockingOverCentralNode/ImGuiDockNodeFlags_NoDockingSplit don't have those issues." + ], + "attached": "// // Disable this node from splitting other windows/nodes." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1956 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDockingOverMe", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// // Disable other windows/nodes from being docked over this node." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1957 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDockingOverOther", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// // Disable this node from being docked over another window or non-empty node." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1958 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDockingOverEmpty", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// // Disable this node from being docked over an empty node (e.g. DockSpace with no other windows)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1959 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDocking", + "value_expression": "ImGuiDockNodeFlags_NoDockingOverMe | ImGuiDockNodeFlags_NoDockingOverOther | ImGuiDockNodeFlags_NoDockingOverEmpty | ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoDockingSplitOther", + "value": 7864336, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1960 + } + }, + { + "name": "ImGuiDockNodeFlags_SharedFlagsInheritMask_", + "value_expression": "~0", + "value": -1, + "is_count": false, + "comments": { + "preceding": [ + "// Masks" + ] + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1963 + } + }, + { + "name": "ImGuiDockNodeFlags_NoResizeFlagsMask_", + "value_expression": "(int)ImGuiDockNodeFlags_NoResize | ImGuiDockNodeFlags_NoResizeX | ImGuiDockNodeFlags_NoResizeY", + "value": 196640, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1964 + } + }, + { + "name": "ImGuiDockNodeFlags_LocalFlagsTransferMask_", + "value_expression": "(int)ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoResizeFlagsMask_ |(int)ImGuiDockNodeFlags_AutoHideTabBar | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton", + "value": 260208, + "is_count": false, + "comments": { + "preceding": [ + "// When splitting, those local flags are moved to the inheriting child, never duplicated" + ] + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1967 + } + }, + { + "name": "ImGuiDockNodeFlags_SavedFlagsMask_", + "value_expression": "ImGuiDockNodeFlags_NoResizeFlagsMask_ | ImGuiDockNodeFlags_DockSpace | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton", + "value": 261152, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 1968 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiDockNodeFlags_" + ] + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1940 + } + }, + { + "name": "ImGuiDataAuthority_", + "original_fully_qualified_name": "ImGuiDataAuthority_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiDataAuthority_Auto", + "value": 0, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1974 + } + }, + { + "name": "ImGuiDataAuthority_DockNode", + "value": 1, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1975 + } + }, + { + "name": "ImGuiDataAuthority_Window", + "value": 2, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1976 + } + } + ], + "comments": { + "preceding": [ + "// Store the source authority (dock node vs window) of a field" + ] + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1972 + } + }, + { + "name": "ImGuiDockNodeState", + "original_fully_qualified_name": "ImGuiDockNodeState", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiDockNodeState_Unknown", + "value": 0, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1981 + } + }, + { + "name": "ImGuiDockNodeState_HostWindowHiddenBecauseSingleWindow", + "value": 1, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1982 + } + }, + { + "name": "ImGuiDockNodeState_HostWindowHiddenBecauseWindowsAreResizing", + "value": 2, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1983 + } + }, + { + "name": "ImGuiDockNodeState_HostWindowVisible", + "value": 3, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1984 + } + } + ], + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1979 + } + }, + { + "name": "ImGuiWindowDockStyleCol", + "original_fully_qualified_name": "ImGuiWindowDockStyleCol", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiWindowDockStyleCol_Text", + "value": 0, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2057 + } + }, + { + "name": "ImGuiWindowDockStyleCol_TabHovered", + "value": 1, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2058 + } + }, + { + "name": "ImGuiWindowDockStyleCol_TabFocused", + "value": 2, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2059 + } + }, + { + "name": "ImGuiWindowDockStyleCol_TabSelected", + "value": 3, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2060 + } + }, + { + "name": "ImGuiWindowDockStyleCol_TabSelectedOverline", + "value": 4, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2061 + } + }, + { + "name": "ImGuiWindowDockStyleCol_TabDimmed", + "value": 5, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2062 + } + }, + { + "name": "ImGuiWindowDockStyleCol_TabDimmedSelected", + "value": 6, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2063 + } + }, + { + "name": "ImGuiWindowDockStyleCol_TabDimmedSelectedOverline", + "value": 7, + "is_count": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2064 + } + }, + { + "name": "ImGuiWindowDockStyleCol_COUNT", + "value": 8, + "is_count": true, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2065 + } + } + ], + "comments": { + "preceding": [ + "// List of colors that are stored at the time of Begin() into Docked Windows.", + "// We currently store the packed colors in a simple array window->DockStyle.Colors[].", + "// A better solution may involve appending into a log of colors in ImGuiContext + store offsets into those arrays in ImGuiWindow,", + "// but it would be more complex as we'd need to double-buffer both as e.g. drop target may refer to window from last frame." + ] + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2055 + } + }, + { + "name": "ImGuiLocKey", + "original_fully_qualified_name": "ImGuiLocKey", + "storage_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiLocKey_VersionStr", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2184 + } + }, + { + "name": "ImGuiLocKey_TableSizeOne", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2185 + } + }, + { + "name": "ImGuiLocKey_TableSizeAllFit", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2186 + } + }, + { + "name": "ImGuiLocKey_TableSizeAllDefault", + "value": 3, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2187 + } + }, + { + "name": "ImGuiLocKey_TableResetOrder", + "value": 4, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2188 + } + }, + { + "name": "ImGuiLocKey_WindowingMainMenuBar", + "value": 5, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2189 + } + }, + { + "name": "ImGuiLocKey_WindowingPopup", + "value": 6, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2190 + } + }, + { + "name": "ImGuiLocKey_WindowingUntitled", + "value": 7, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2191 + } + }, + { + "name": "ImGuiLocKey_OpenLink_s", + "value": 8, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2192 + } + }, + { + "name": "ImGuiLocKey_CopyLink", + "value": 9, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2193 + } + }, + { + "name": "ImGuiLocKey_DockingHideTabBar", + "value": 10, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2194 + } + }, + { + "name": "ImGuiLocKey_DockingHoldShiftToDock", + "value": 11, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2195 + } + }, + { + "name": "ImGuiLocKey_DockingDragToUndockOrMoveNode", + "value": 12, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2196 + } + }, + { + "name": "ImGuiLocKey_COUNT", + "value": 13, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2197 + } + } + ], + "comments": { + "preceding": [ + "// This is experimental and not officially supported, it'll probably fall short of features, if/when it does we may backtrack." + ], + "attached": "// Forward declared enum type ImGuiLocKey" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2182 + } + }, + { + "name": "ImGuiDebugLogFlags_", + "original_fully_qualified_name": "ImGuiDebugLogFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiDebugLogFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "preceding": [ + "// Event types" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2230 + } + }, + { + "name": "ImGuiDebugLogFlags_EventError", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Error submitted by IM_ASSERT_USER_ERROR()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2231 + } + }, + { + "name": "ImGuiDebugLogFlags_EventActiveId", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2232 + } + }, + { + "name": "ImGuiDebugLogFlags_EventFocus", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2233 + } + }, + { + "name": "ImGuiDebugLogFlags_EventPopup", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2234 + } + }, + { + "name": "ImGuiDebugLogFlags_EventNav", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2235 + } + }, + { + "name": "ImGuiDebugLogFlags_EventClipper", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2236 + } + }, + { + "name": "ImGuiDebugLogFlags_EventSelection", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2237 + } + }, + { + "name": "ImGuiDebugLogFlags_EventIO", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2238 + } + }, + { + "name": "ImGuiDebugLogFlags_EventFont", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2239 + } + }, + { + "name": "ImGuiDebugLogFlags_EventInputRouting", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2240 + } + }, + { + "name": "ImGuiDebugLogFlags_EventDocking", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2241 + } + }, + { + "name": "ImGuiDebugLogFlags_EventViewport", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2242 + } + }, + { + "name": "ImGuiDebugLogFlags_EventMask_", + "value_expression": "ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventFont | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport", + "value": 4095, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 2244 + } + }, + { + "name": "ImGuiDebugLogFlags_OutputToTTY", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// Also send output to TTY" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2245 + } + }, + { + "name": "ImGuiDebugLogFlags_OutputToTestEngine", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// Also send output to Test Engine" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2246 + } + } + ], + "comments": { + "preceding": [ + "// See IMGUI_DEBUG_LOG() and IMGUI_DEBUG_LOG_XXX() macros." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2227 + } + }, + { + "name": "ImGuiContextHookType", + "original_fully_qualified_name": "ImGuiContextHookType", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiContextHookType_NewFramePre", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiContextHookType_NewFramePost", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiContextHookType_EndFramePre", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiContextHookType_EndFramePost", + "value": 3, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiContextHookType_RenderPre", + "value": 4, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiContextHookType_RenderPost", + "value": 5, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiContextHookType_Shutdown", + "value": 6, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiContextHookType_PendingRemoval_", + "value": 7, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2315 + } + }, + { + "name": "ImGuiTabBarFlagsPrivate_", + "original_fully_qualified_name": "ImGuiTabBarFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiTabBarFlags_DockNode", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// Part of a dock node [we don't use this in the master branch but it facilitate branch syncing to keep this around]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2947 + } + }, + { + "name": "ImGuiTabBarFlags_IsFocused", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2948 + } + }, + { + "name": "ImGuiTabBarFlags_SaveSettings", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// FIXME: Settings are handled by the docking system, this only request the tab bar to mark settings dirty when reordering tabs" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2949 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiTabBarFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2945 + } + }, + { + "name": "ImGuiTabItemFlagsPrivate_", + "original_fully_qualified_name": "ImGuiTabItemFlagsPrivate_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiTabItemFlags_SectionMask_", + "value_expression": "ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing", + "value": 192, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 2955 + } + }, + { + "name": "ImGuiTabItemFlags_NoCloseButton", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// Track whether p_open was set or not (we'll need this info on the next frame to recompute ContentWidth during layout)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2956 + } + }, + { + "name": "ImGuiTabItemFlags_Button", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// Used by TabItemButton, change the tab item behavior to mimic a button" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2957 + } + }, + { + "name": "ImGuiTabItemFlags_Invisible", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// To reserve space e.g. with ImGuiTabItemFlags_Leading" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2958 + } + }, + { + "name": "ImGuiTabItemFlags_Unsorted", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "attached": "// [Docking] Trailing tabs with the _Unsorted flag will be sorted based on the DockOrder of their Window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2959 + } + } + ], + "comments": { + "preceding": [ + "// Extend ImGuiTabItemFlags_" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2953 + } + } + ], + "typedefs": [ + { + "name": "ImGuiTableColumnIdx", + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "preceding": [ + "// Table column indexing" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiLocKey", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Enumerations", + "// Use your programming IDE \"Go to definition\" facility on the names of the center columns to find the actual flags/enum lists." + ], + "attached": "// -> enum ImGuiLocKey // Enum: a localization entry for translation." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiDataAuthority", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiDataAuthority_ // Enum: for storing the source authority (dock node vs window) of a field" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiLayoutType", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiLayoutType_ // Enum: Horizontal or vertical" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiActivateFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Flags" + ], + "attached": "// -> enum ImGuiActivateFlags_ // Flags: for navigation/focus function (will be for ActivateItem() later)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiDebugLogFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiDebugLogFlags_ // Flags: for ShowDebugLogWindow(), g.DebugLogFlags" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiFocusRequestFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiFocusRequestFlags_ // Flags: for FocusWindow()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiItemStatusFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiItemStatusFlags_ // Flags: for g.LastItemData.StatusFlags" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiOldColumnFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiOldColumnFlags_ // Flags: for BeginColumns()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiLogFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiLogFlags_ // Flags: for LogBegin() text capturing function" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiNavRenderCursorFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiNavRenderCursorFlags_//Flags: for RenderNavCursor()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiNavMoveFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiNavMoveFlags_ // Flags: for navigation requests" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiNextItemDataFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiNextItemDataFlags_ // Flags: for SetNextItemXXX() functions" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiNextWindowDataFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiScrollFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiScrollFlags_ // Flags: for ScrollToItem() and navigation requests" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiSeparatorFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiSeparatorFlags_ // Flags: for SeparatorEx()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiTextFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTextFlags_ // Flags: for TextEx()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiTooltipFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTooltipFlags_ // Flags: for BeginTooltipEx()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiTypingSelectFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTypingSelectFlags_ // Flags: for GetTypingSelectRequest()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiWindowRefreshFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiWindowRefreshFlags_ // Flags: for SetNextWindowRefreshPolicy()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiTableDrawChannelIdx", + "type": { + "declaration": "ImU16", + "description": { + "kind": "User", + "name": "ImU16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImFileHandle", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImFileHandle", + "type": { + "declaration": "FILE*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "FILE" + } + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImBitArrayPtr", + "type": { + "declaration": "ImU32*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "comments": { + "attached": "// Name for use in structs" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImPoolIdx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Helper: ImPool<>", + "// Basic keyed storage for contiguous instances, slow/amortized insertion, O(1) indexable, O(Log N) queries by ID over a dense/hot buffer,", + "// Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiKeyRoutingIndex", + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiErrorCallback", + "type": { + "declaration": "void (*ImGuiErrorCallback)(ImGuiContext* ctx, void* user_data, const char* msg)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "msg", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ImGuiErrorCallback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "msg", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// The error callback is currently not public, as it is expected that only advanced users will rely on it." + ], + "attached": "// Function signature for g.ErrorCallback" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImGuiContextHookCallback", + "type": { + "declaration": "void (*ImGuiContextHookCallback)(ImGuiContext* ctx, ImGuiContextHook* hook)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hook", + "type": { + "declaration": "ImGuiContextHook*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContextHook" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ImGuiContextHookCallback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "hook", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContextHook" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ImFontBuilderIO", + "type": { + "declaration": "ImFontLoader", + "description": { + "kind": "User", + "name": "ImFontLoader" + } + }, + "comments": { + "attached": "// [renamed/changed in 1.92] The types are not actually compatible but we provide this as a compile-time error report helper." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "stbrp_node_im", + "type": { + "declaration": "IMGUI_STB_NAMESPACE::stbrp_node", + "description": { + "kind": "User", + "name": "IMGUI_STB_NAMESPACE::stbrp_node" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "stbrp_node_im", + "type": { + "declaration": "stbrp_node", + "description": { + "kind": "User", + "name": "stbrp_node" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + } + ], + "structs": [ + { + "name": "ImVector_ImFontBakedPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontBaked**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImFontAtlasPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlas**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImGuiDockRequest", + "original_fully_qualified_name": "ImGuiDockRequest", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "attached": "// Docking system dock/undock queued request" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 156 + } + }, + { + "name": "ImGuiDockNodeSettings", + "original_fully_qualified_name": "ImGuiDockNodeSettings", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "attached": "// Storage for a dock node in .ini file (we preserve those even if the associated dock node isn't active during the session)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 158 + } + }, + { + "name": "ImGuiInputTextDeactivateData", + "original_fully_qualified_name": "ImGuiInputTextDeactivateData", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "attached": "// Short term storage to backup text of a deactivating InputText() while another is stealing active id" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 162 + } + }, + { + "name": "ImGuiTableColumnsSettings", + "original_fully_qualified_name": "ImGuiTableColumnsSettings", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "attached": "// Storage for a column .ini settings" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 186 + } + }, + { + "name": "ImVec1", + "original_fully_qualified_name": "ImVec1", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "x", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 545 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 543 + } + }, + { + "name": "ImVec2i", + "original_fully_qualified_name": "ImVec2i", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "x", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 553 + } + }, + { + "name": "y", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 553 + } + } + ], + "comments": { + "preceding": [ + "// Helper: ImVec2i (2D vector, integer)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 551 + } + }, + { + "name": "ImVec2ih", + "original_fully_qualified_name": "ImVec2ih", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "x", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 561 + } + }, + { + "name": "y", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 561 + } + } + ], + "comments": { + "preceding": [ + "// Helper: ImVec2ih (2D vector, half-size integer, for long-term packed storage)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 559 + } + }, + { + "name": "ImRect", + "original_fully_qualified_name": "ImRect", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Min", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Upper-left" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 571 + } + }, + { + "name": "Max", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Lower-right" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 572 + } + } + ], + "comments": { + "preceding": [ + "// Helper: ImRect (2D axis aligned bounding-box)", + "// NB: we can't rely on ImVec2 math operators being available here!" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 569 + } + }, + { + "name": "ImBitVector", + "original_fully_qualified_name": "ImBitVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Storage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImU32", + "description": { + "kind": "User", + "name": "ImVector_ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 649 + } + } + ], + "comments": { + "preceding": [ + "// Helper: ImBitVector", + "// Store 1-bit per value." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 647 + } + }, + { + "name": "ImSpan_ImGuiTableColumn", + "original_fully_qualified_name": "ImSpan", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumn*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumn" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 663 + } + }, + { + "name": "DataEnd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumn*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumn" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 664 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImSpan" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 661 + } + }, + { + "name": "ImSpan_ImGuiTableColumnIdx", + "original_fully_qualified_name": "ImSpan", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 663 + } + }, + { + "name": "DataEnd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 664 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImSpan" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 661 + } + }, + { + "name": "ImSpan_ImGuiTableCellData", + "original_fully_qualified_name": "ImSpan", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableCellData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableCellData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 663 + } + }, + { + "name": "DataEnd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableCellData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableCellData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 664 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImSpan" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 661 + } + }, + { + "name": "ImStableVector_ImFontBaked_32", + "original_fully_qualified_name": "ImStableVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "default_value": "0", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 716 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "default_value": "0", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 717 + } + }, + { + "name": "Blocks", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontBakedPtr", + "description": { + "kind": "User", + "name": "ImVector_ImFontBakedPtr" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 718 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImStableVector" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 714 + } + }, + { + "name": "ImDrawListSharedData", + "original_fully_qualified_name": "ImDrawListSharedData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "TexUvWhitePixel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// UV of white pixel in the atlas (== FontAtlas->TexUvWhitePixel)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 850 + } + }, + { + "name": "TexUvLines", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const ImVec4*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec4", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// UV of anti-aliased lines in the atlas (== FontAtlas->TexUvLines)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 851 + } + }, + { + "name": "FontAtlas", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "comments": { + "attached": "// Current font atlas" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 852 + } + }, + { + "name": "Font", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "comments": { + "attached": "// Current font (used for simplified AddText overload)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 853 + } + }, + { + "name": "FontSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Current font size (used for for simplified AddText overload)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 854 + } + }, + { + "name": "FontScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Current font scale (== FontSize / Font->FontSize)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 855 + } + }, + { + "name": "CurveTessellationTol", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Tessellation tolerance when using PathBezierCurveTo()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 856 + } + }, + { + "name": "CircleSegmentMaxError", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Number of circle segments to use per pixel of radius for AddCircle() etc" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 857 + } + }, + { + "name": "InitialFringeScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Initial scale to apply to AA fringe" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 858 + } + }, + { + "name": "InitialFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListFlags", + "description": { + "kind": "User", + "name": "ImDrawListFlags" + } + }, + "comments": { + "attached": "// Initial flags at the beginning of the frame (it is possible to alter flags on a per-drawlist basis afterwards)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 859 + } + }, + { + "name": "ClipRectFullscreen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "comments": { + "attached": "// Value for PushClipRectFullscreen()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 860 + } + }, + { + "name": "TempBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImVec2", + "description": { + "kind": "User", + "name": "ImVector_ImVec2" + } + }, + "comments": { + "attached": "// Temporary write buffer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 861 + } + }, + { + "name": "DrawLists", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawListPtr", + "description": { + "kind": "User", + "name": "ImVector_ImDrawListPtr" + } + }, + "comments": { + "attached": "// All draw lists associated to this ImDrawListSharedData" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 862 + } + }, + { + "name": "Context", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "comments": { + "attached": "// [OPTIONAL] Link to Dear ImGui context. 99% of ImDrawList/ImFontAtlas can function without an ImGui context, but this facilitate handling one legacy edge case." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 863 + } + }, + { + "name": "ArcFastVtx", + "is_array": true, + "array_bounds": "IM_DRAWLIST_ARCFAST_TABLE_SIZE", + "is_anonymous": false, + "type": { + "declaration": "ImVec2[IM_DRAWLIST_ARCFAST_TABLE_SIZE]", + "description": { + "kind": "Array", + "bounds": "IM_DRAWLIST_ARCFAST_TABLE_SIZE", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "comments": { + "preceding": [ + "// Lookup tables" + ], + "attached": "// Sample points on the quarter of the circle." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 866 + } + }, + { + "name": "ArcFastRadiusCutoff", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Cutoff radius after which arc drawing will fallback to slower PathArcTo()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 867 + } + }, + { + "name": "CircleSegmentCounts", + "is_array": true, + "array_bounds": "64", + "is_anonymous": false, + "type": { + "declaration": "ImU8[64]", + "description": { + "kind": "Array", + "bounds": "64", + "inner_type": { + "kind": "User", + "name": "ImU8" + } + } + }, + "comments": { + "attached": "// Precomputed segment count for given radius before we calculate it dynamically (to avoid calculation overhead)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 868 + } + } + ], + "comments": { + "preceding": [ + "// Data shared between all ImDrawList instances", + "// Conceptually this could have been called e.g. ImDrawListSharedContext", + "// Typically one ImGui context would create and maintain one of this.", + "// You may want to create your own instance of you try to ImDrawList completely without ImGui. In that case, watch out for future changes to this structure." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 848 + } + }, + { + "name": "ImDrawDataBuilder", + "original_fully_qualified_name": "ImDrawDataBuilder", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Layers", + "is_array": true, + "array_bounds": "2", + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawListPtr*[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_ImDrawListPtr" + } + } + } + }, + "comments": { + "attached": "// Pointers to global layers for: regular, tooltip. LayersP[0] is owned by DrawData." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 877 + } + }, + { + "name": "LayerData1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawListPtr", + "description": { + "kind": "User", + "name": "ImVector_ImDrawListPtr" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 878 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 875 + } + }, + { + "name": "ImFontStackData", + "original_fully_qualified_name": "ImFontStackData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Font", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 885 + } + }, + { + "name": "FontSizeBeforeScaling", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// ~~ style.FontSizeBase" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 886 + } + }, + { + "name": "FontSizeAfterScaling", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// ~~ g.FontSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 887 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 883 + } + }, + { + "name": "ImVector_ImFontStackData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontStackData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontStackData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImGuiStyleVarInfo", + "original_fully_qualified_name": "ImGuiStyleVarInfo", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Count", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// 1+" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 896 + } + }, + { + "name": "DataType", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 897 + } + }, + { + "name": "Offset", + "is_array": false, + "width": 16, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// Offset in parent structure" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 898 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 894 + } + }, + { + "name": "ImGuiColorMod", + "original_fully_qualified_name": "ImGuiColorMod", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Col", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 905 + } + }, + { + "name": "BackupValue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 906 + } + } + ], + "comments": { + "preceding": [ + "// Stacked color modifier, backup of modified data so we can restore it" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 903 + } + }, + { + "name": "ImGuiStyleMod", + "original_fully_qualified_name": "ImGuiStyleMod", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "VarIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStyleVar", + "description": { + "kind": "User", + "name": "ImGuiStyleVar" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 912 + } + }, + { + "name": "__anonymous_type2", + "is_array": false, + "is_anonymous": true, + "type": { + "declaration": "__anonymous_type2", + "description": { + "kind": "User", + "name": "__anonymous_type2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + } + ], + "comments": { + "preceding": [ + "// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 910 + } + }, + { + "name": "__anonymous_type2", + "original_fully_qualified_name": "ImGuiStyleMod::", + "kind": "union", + "by_value": false, + "forward_declaration": false, + "is_anonymous": true, + "fields": [ + { + "name": "BackupInt", + "is_array": true, + "array_bounds": "2", + "is_anonymous": false, + "type": { + "declaration": "int[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 913 + } + }, + { + "name": "BackupFloat", + "is_array": true, + "array_bounds": "2", + "is_anonymous": false, + "type": { + "declaration": "float[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 913 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 913 + } + }, + { + "name": "ImGuiDataTypeStorage", + "original_fully_qualified_name": "ImGuiDataTypeStorage", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Data", + "is_array": true, + "array_bounds": "8", + "is_anonymous": false, + "type": { + "declaration": "ImU8[8]", + "description": { + "kind": "Array", + "bounds": "8", + "inner_type": { + "kind": "User", + "name": "ImU8" + } + } + }, + "comments": { + "attached": "// Opaque storage to fit any data up to ImGuiDataType_COUNT" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 925 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 923 + } + }, + { + "name": "ImGuiDataTypeInfo", + "original_fully_qualified_name": "ImGuiDataTypeInfo", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "comments": { + "attached": "// Size in bytes" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 931 + } + }, + { + "name": "Name", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Short descriptive name for the type, for debugging" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 932 + } + }, + { + "name": "PrintFmt", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Default printf format for the type" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 933 + } + }, + { + "name": "ScanFmt", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Default scanf format for the type" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 934 + } + } + ], + "comments": { + "preceding": [ + "// Type information associated to one ImGuiDataType. Retrieve with DataTypeGetInfo()." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 929 + } + }, + { + "name": "ImChunkStream_ImGuiTableSettings", + "original_fully_qualified_name": "ImChunkStream", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Buf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 783 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImChunkStream" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 781 + } + }, + { + "name": "ImChunkStream_ImGuiWindowSettings", + "original_fully_qualified_name": "ImChunkStream", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Buf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 783 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImChunkStream" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 781 + } + }, + { + "name": "ImVector_unsigned_char", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiWindowStackData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowStackData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowStackData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiWindowPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiViewportPPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportP**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTreeNodeStackData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTreeNodeStackData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTreeNodeStackData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTableTempData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableTempData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableTempData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTableInstanceData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableInstanceData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableInstanceData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTableHeaderData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableHeaderData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableHeaderData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTableColumnSortSpecs", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnSortSpecs*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumnSortSpecs" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTable", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTabItem", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiTabBar", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiStyleMod", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStyleMod*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStyleMod" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiStackLevelInfo", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStackLevelInfo*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStackLevelInfo" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiShrinkWidthItem", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiShrinkWidthItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiShrinkWidthItem" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiSettingsHandler", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiPtrOrIndex", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPtrOrIndex*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPtrOrIndex" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiPopupData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPopupData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPopupData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiOldColumns", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiOldColumns*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiOldColumns" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiOldColumnData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiOldColumnData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiOldColumnData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiMultiSelectTempData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMultiSelectTempData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectTempData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiMultiSelectState", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMultiSelectState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectState" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiListClipperRange", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiListClipperRange*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiListClipperRange" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiListClipperData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiListClipperData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiListClipperData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiKeyRoutingData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyRoutingData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyRoutingData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiItemFlags", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemFlags*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiItemFlags" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiInputEvent", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEvent*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiInputEvent" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiID", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiID" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiGroupData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiGroupData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiGroupData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiFocusScopeData", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiFocusScopeData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiFocusScopeData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiDockRequest", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockRequest*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockRequest" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiDockNodeSettings", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNodeSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNodeSettings" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiContextHook", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContextHook*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContextHook" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiColorMod", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiColorMod*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiColorMod" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_const_charPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImVector_int", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImPool_ImGuiMultiSelectState", + "original_fully_qualified_name": "ImPool", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Buf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiMultiSelectState", + "description": { + "kind": "User", + "name": "ImVector_ImGuiMultiSelectState" + } + }, + "comments": { + "attached": "// Contiguous data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 749 + } + }, + { + "name": "Map", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// ID->Index" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 750 + } + }, + { + "name": "FreeIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPoolIdx", + "description": { + "kind": "User", + "name": "ImPoolIdx" + } + }, + "comments": { + "attached": "// Next free idx to use" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 751 + } + }, + { + "name": "AliveCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPoolIdx", + "description": { + "kind": "User", + "name": "ImPoolIdx" + } + }, + "comments": { + "attached": "// Number of active/alive items (for display purpose)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 752 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImPool" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 747 + } + }, + { + "name": "ImPool_ImGuiTabBar", + "original_fully_qualified_name": "ImPool", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Buf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTabBar", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTabBar" + } + }, + "comments": { + "attached": "// Contiguous data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 749 + } + }, + { + "name": "Map", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// ID->Index" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 750 + } + }, + { + "name": "FreeIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPoolIdx", + "description": { + "kind": "User", + "name": "ImPoolIdx" + } + }, + "comments": { + "attached": "// Next free idx to use" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 751 + } + }, + { + "name": "AliveCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPoolIdx", + "description": { + "kind": "User", + "name": "ImPoolIdx" + } + }, + "comments": { + "attached": "// Number of active/alive items (for display purpose)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 752 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImPool" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 747 + } + }, + { + "name": "ImPool_ImGuiTable", + "original_fully_qualified_name": "ImPool", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Buf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTable", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTable" + } + }, + "comments": { + "attached": "// Contiguous data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 749 + } + }, + { + "name": "Map", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// ID->Index" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 750 + } + }, + { + "name": "FreeIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPoolIdx", + "description": { + "kind": "User", + "name": "ImPoolIdx" + } + }, + "comments": { + "attached": "// Next free idx to use" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 751 + } + }, + { + "name": "AliveCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPoolIdx", + "description": { + "kind": "User", + "name": "ImPoolIdx" + } + }, + "comments": { + "attached": "// Number of active/alive items (for display purpose)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 752 + } + } + ], + "comments": { + "preceding": [ + "// Instantiation of ImPool" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 747 + } + }, + { + "name": "ImGuiTextIndex", + "original_fully_qualified_name": "ImGuiTextIndex", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "LineOffsets", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_int", + "description": { + "kind": "User", + "name": "ImVector_int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 802 + } + }, + { + "name": "EndOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "default_value": "0", + "comments": { + "attached": "// Because we don't own text buffer we need to maintain EndOffset (may bake in LineOffsets?)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 803 + } + } + ], + "comments": { + "preceding": [ + "// Helper: ImGuiTextIndex", + "// Maintain a line index for a text buffer. This is a strong candidate to be moved into the public API." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 800 + } + }, + { + "name": "ImGuiComboPreviewData", + "original_fully_qualified_name": "ImGuiComboPreviewData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "PreviewRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1150 + } + }, + { + "name": "BackupCursorPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1151 + } + }, + { + "name": "BackupCursorMaxPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1152 + } + }, + { + "name": "BackupCursorPosPrevLine", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1153 + } + }, + { + "name": "BackupPrevLineTextBaseOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1154 + } + }, + { + "name": "BackupLayout", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiLayoutType", + "description": { + "kind": "User", + "name": "ImGuiLayoutType" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1155 + } + } + ], + "comments": { + "preceding": [ + "// Storage data for BeginComboPreview()/EndComboPreview()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1148 + } + }, + { + "name": "ImGuiGroupData", + "original_fully_qualified_name": "ImGuiGroupData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "WindowID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1163 + } + }, + { + "name": "BackupCursorPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1164 + } + }, + { + "name": "BackupCursorMaxPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1165 + } + }, + { + "name": "BackupCursorPosPrevLine", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1166 + } + }, + { + "name": "BackupIndent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec1", + "description": { + "kind": "User", + "name": "ImVec1" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1167 + } + }, + { + "name": "BackupGroupOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec1", + "description": { + "kind": "User", + "name": "ImVec1" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1168 + } + }, + { + "name": "BackupCurrLineSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1169 + } + }, + { + "name": "BackupCurrLineTextBaseOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1170 + } + }, + { + "name": "BackupActiveIdIsAlive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1171 + } + }, + { + "name": "BackupDeactivatedIdIsAlive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1172 + } + }, + { + "name": "BackupHoveredIdIsAlive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1173 + } + }, + { + "name": "BackupIsSameLine", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1174 + } + }, + { + "name": "EmitItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1175 + } + } + ], + "comments": { + "preceding": [ + "// Stacked storage data for BeginGroup()/EndGroup()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1161 + } + }, + { + "name": "ImGuiMenuColumns", + "original_fully_qualified_name": "ImGuiMenuColumns", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "TotalWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1181 + } + }, + { + "name": "NextTotalWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1182 + } + }, + { + "name": "Spacing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU16", + "description": { + "kind": "User", + "name": "ImU16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1183 + } + }, + { + "name": "OffsetIcon", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU16", + "description": { + "kind": "User", + "name": "ImU16" + } + }, + "comments": { + "attached": "// Always zero for now" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1184 + } + }, + { + "name": "OffsetLabel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU16", + "description": { + "kind": "User", + "name": "ImU16" + } + }, + "comments": { + "attached": "// Offsets are locked in Update()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1185 + } + }, + { + "name": "OffsetShortcut", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU16", + "description": { + "kind": "User", + "name": "ImU16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1186 + } + }, + { + "name": "OffsetMark", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU16", + "description": { + "kind": "User", + "name": "ImU16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1187 + } + }, + { + "name": "Widths", + "is_array": true, + "array_bounds": "4", + "is_anonymous": false, + "type": { + "declaration": "ImU16[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "User", + "name": "ImU16" + } + } + }, + "comments": { + "attached": "// Width of: Icon, Label, Shortcut, Mark (accumulators for current frame)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1188 + } + } + ], + "comments": { + "preceding": [ + "// Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1179 + } + }, + { + "name": "ImGuiInputTextDeactivatedState", + "original_fully_qualified_name": "ImGuiInputTextDeactivatedState", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// widget id owning the text state (which just got deactivated)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1199 + } + }, + { + "name": "TextA", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "comments": { + "attached": "// text buffer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1200 + } + } + ], + "comments": { + "preceding": [ + "// Internal temporary state for deactivating InputText() instances." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1197 + } + }, + { + "name": "ImStb_STB_TexteditState", + "original_fully_qualified_name": "ImStb::STB_TexteditState", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1214 + } + }, + { + "name": "ImGuiInputTextState", + "original_fully_qualified_name": "ImGuiInputTextState", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Ctx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "comments": { + "attached": "// parent UI context (needs to be set explicitly by parent)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1221 + } + }, + { + "name": "Stb", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// State for stb_textedit.h" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1222 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "comments": { + "attached": "// copy of InputText() flags. may be used to check if e.g. ImGuiInputTextFlags_Password is set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1223 + } + }, + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// widget id owning the text state" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1224 + } + }, + { + "name": "TextLen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// UTF-8 length of the string in TextA (in bytes)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1225 + } + }, + { + "name": "TextSrc", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// == TextA.Data unless read-only, in which case == buf passed to InputText(). Field only set and valid _inside_ the call InputText() call." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1226 + } + }, + { + "name": "TextA", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "comments": { + "attached": "// main UTF8 buffer. TextA.Size is a buffer size! Should always be >= buf_size passed by user (and of course >= CurLenA + 1)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1227 + } + }, + { + "name": "TextToRevertTo", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "comments": { + "attached": "// value to revert to when pressing Escape = backup of end-user buffer at the time of focus (in UTF-8, unaltered)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1228 + } + }, + { + "name": "CallbackTextBackup", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "comments": { + "attached": "// temporary storage for callback to support automatic reconcile of undo-stack" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1229 + } + }, + { + "name": "BufCapacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// end-user buffer capacity (include zero terminator)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1230 + } + }, + { + "name": "Scroll", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// horizontal offset (managed manually) + vertical scrolling (pulled from child window's own Scroll.y)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1231 + } + }, + { + "name": "CursorAnim", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// timer for cursor blink, reset on every user action so the cursor reappears immediately" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1232 + } + }, + { + "name": "CursorFollow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// set when we want scrolling to follow the current cursor position (not always!)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1233 + } + }, + { + "name": "SelectedAllMouseLock", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// after a double-click to select all, we ignore further mouse drags to update selection" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1234 + } + }, + { + "name": "Edited", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// edited this frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1235 + } + }, + { + "name": "WantReloadUserBuf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// force a reload of user buf so it may be modified externally. may be automatic in future version." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1236 + } + }, + { + "name": "ReloadSelectionStart", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1237 + } + }, + { + "name": "ReloadSelectionEnd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1238 + } + } + ], + "comments": { + "preceding": [ + "// Internal state of the currently focused/edited text input box", + "// For a given item ID, access with ImGui::GetInputTextState()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1219 + } + }, + { + "name": "ImGuiNextWindowData", + "original_fully_qualified_name": "ImGuiNextWindowData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "HasFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNextWindowDataFlags", + "description": { + "kind": "User", + "name": "ImGuiNextWindowDataFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1298 + } + }, + { + "name": "PosCond", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "comments": { + "preceding": [ + "// Members below are NOT cleared. Always rely on HasFlags." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1301 + } + }, + { + "name": "SizeCond", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1302 + } + }, + { + "name": "CollapsedCond", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1303 + } + }, + { + "name": "DockCond", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1304 + } + }, + { + "name": "PosVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1305 + } + }, + { + "name": "PosPivotVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1306 + } + }, + { + "name": "SizeVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1307 + } + }, + { + "name": "ContentSizeVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1308 + } + }, + { + "name": "ScrollVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1309 + } + }, + { + "name": "WindowFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "comments": { + "attached": "// Only honored by BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1310 + } + }, + { + "name": "ChildFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiChildFlags", + "description": { + "kind": "User", + "name": "ImGuiChildFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1311 + } + }, + { + "name": "PosUndock", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1312 + } + }, + { + "name": "CollapsedVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1313 + } + }, + { + "name": "SizeConstraintRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1314 + } + }, + { + "name": "SizeCallback", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSizeCallback", + "description": { + "kind": "User", + "name": "ImGuiSizeCallback" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1315 + } + }, + { + "name": "SizeCallbackUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1316 + } + }, + { + "name": "BgAlphaVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Override background alpha" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1317 + } + }, + { + "name": "ViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1318 + } + }, + { + "name": "DockId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1319 + } + }, + { + "name": "WindowClass", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowClass", + "description": { + "kind": "User", + "name": "ImGuiWindowClass" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1320 + } + }, + { + "name": "MenuBarOffsetMinVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// (Always on) This is not exposed publicly, so we don't clear it and it doesn't have a corresponding flag (could we? for consistency?)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1321 + } + }, + { + "name": "RefreshFlagsVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowRefreshFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowRefreshFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1322 + } + } + ], + "comments": { + "preceding": [ + "// Storage for SetNexWindow** functions" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1296 + } + }, + { + "name": "ImGuiNextItemData", + "original_fully_qualified_name": "ImGuiNextItemData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "HasFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNextItemDataFlags", + "description": { + "kind": "User", + "name": "ImGuiNextItemDataFlags" + } + }, + "comments": { + "attached": "// Called HasFlags instead of Flags to avoid mistaking this" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1340 + } + }, + { + "name": "ItemFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "comments": { + "attached": "// Currently only tested/used for ImGuiItemFlags_AllowOverlap and ImGuiItemFlags_HasSelectionUserData." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1341 + } + }, + { + "name": "FocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// Members below are NOT cleared by ItemAdd() meaning they are still valid during e.g. NavProcessItem(). Always rely on HasFlags." + ], + "attached": "// Set by SetNextItemSelectionUserData()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1344 + } + }, + { + "name": "SelectionUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// Set by SetNextItemSelectionUserData() (note that NULL/0 is a valid value, we use -1 == ImGuiSelectionUserData_Invalid to mark invalid values)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1345 + } + }, + { + "name": "Width", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Set by SetNextItemWidth()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1346 + } + }, + { + "name": "Shortcut", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "attached": "// Set by SetNextItemShortcut()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1347 + } + }, + { + "name": "ShortcutFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "comments": { + "attached": "// Set by SetNextItemShortcut()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1348 + } + }, + { + "name": "OpenVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set by SetNextItemOpen()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1349 + } + }, + { + "name": "OpenCond", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Set by SetNextItemOpen()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1350 + } + }, + { + "name": "RefVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataTypeStorage", + "description": { + "kind": "User", + "name": "ImGuiDataTypeStorage" + } + }, + "comments": { + "attached": "// Not exposed yet, for ImGuiInputTextFlags_ParseEmptyAsRefVal" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1351 + } + }, + { + "name": "StorageId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set by SetNextItemStorageID()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1352 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1338 + } + }, + { + "name": "ImGuiLastItemData", + "original_fully_qualified_name": "ImGuiLastItemData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1361 + } + }, + { + "name": "ItemFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "comments": { + "attached": "// See ImGuiItemFlags_ (called 'InFlags' before v1.91.4)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1362 + } + }, + { + "name": "StatusFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemStatusFlags", + "description": { + "kind": "User", + "name": "ImGuiItemStatusFlags" + } + }, + "comments": { + "attached": "// See ImGuiItemStatusFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1363 + } + }, + { + "name": "Rect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Full rectangle" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1364 + } + }, + { + "name": "NavRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Navigation scoring rectangle (not displayed)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1365 + } + }, + { + "name": "DisplayRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "preceding": [ + "// Rarely used fields are not explicitly cleared, only valid when the corresponding ImGuiItemStatusFlags are set." + ], + "attached": "// Display rectangle. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasDisplayRect) is set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1367 + } + }, + { + "name": "ClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Clip rectangle at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasClipRect) is set.." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1368 + } + }, + { + "name": "Shortcut", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "attached": "// Shortcut at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasShortcut) is set.." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1369 + } + } + ], + "comments": { + "preceding": [ + "// Status storage for the last submitted item" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1359 + } + }, + { + "name": "ImGuiTreeNodeStackData", + "original_fully_qualified_name": "ImGuiTreeNodeStackData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1380 + } + }, + { + "name": "TreeFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1381 + } + }, + { + "name": "ItemFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "comments": { + "attached": "// Used for nav landing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1382 + } + }, + { + "name": "NavRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Used for nav landing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1383 + } + }, + { + "name": "DrawLinesX1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1384 + } + }, + { + "name": "DrawLinesToNodesY2", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1385 + } + }, + { + "name": "DrawLinesTableColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1386 + } + } + ], + "comments": { + "preceding": [ + "// Store data emitted by TreeNode() for usage by TreePop()", + "// - To implement ImGuiTreeNodeFlags_NavLeftJumpsToParent: store the minimum amount of data", + "// which we can't infer in TreePop(), to perform the equivalent of NavApplyItemToResult().", + "// Only stored when the node is a potential candidate for landing on a Left arrow jump." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1378 + } + }, + { + "name": "ImGuiErrorRecoveryState", + "original_fully_qualified_name": "ImGuiErrorRecoveryState", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "SizeOfWindowStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1392 + } + }, + { + "name": "SizeOfIDStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1393 + } + }, + { + "name": "SizeOfTreeStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1394 + } + }, + { + "name": "SizeOfColorStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1395 + } + }, + { + "name": "SizeOfStyleVarStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1396 + } + }, + { + "name": "SizeOfFontStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1397 + } + }, + { + "name": "SizeOfFocusScopeStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1398 + } + }, + { + "name": "SizeOfGroupStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1399 + } + }, + { + "name": "SizeOfItemFlagsStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1400 + } + }, + { + "name": "SizeOfBeginPopupStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1401 + } + }, + { + "name": "SizeOfDisabledStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1402 + } + } + ], + "comments": { + "preceding": [ + "// sizeof() = 20" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1390 + } + }, + { + "name": "ImGuiWindowStackData", + "original_fully_qualified_name": "ImGuiWindowStackData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1410 + } + }, + { + "name": "ParentLastItemDataBackup", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiLastItemData", + "description": { + "kind": "User", + "name": "ImGuiLastItemData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1411 + } + }, + { + "name": "StackSizesInBegin", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiErrorRecoveryState", + "description": { + "kind": "User", + "name": "ImGuiErrorRecoveryState" + } + }, + "comments": { + "attached": "// Store size of various stacks for asserting" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1412 + } + }, + { + "name": "DisabledOverrideReenable", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Non-child window override disabled flag" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1413 + } + }, + { + "name": "DisabledOverrideReenableAlphaBackup", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1414 + } + } + ], + "comments": { + "preceding": [ + "// Data saved for each window pushed into the stack" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1408 + } + }, + { + "name": "ImGuiShrinkWidthItem", + "original_fully_qualified_name": "ImGuiShrinkWidthItem", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Index", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1419 + } + }, + { + "name": "Width", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1420 + } + }, + { + "name": "InitialWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1421 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1417 + } + }, + { + "name": "ImGuiPtrOrIndex", + "original_fully_qualified_name": "ImGuiPtrOrIndex", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Ptr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Either field can be set, not both. e.g. Dock node tab bars are loose while BeginTabBar() ones are in a pool." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1426 + } + }, + { + "name": "Index", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Usually index in a main pool." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1427 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1424 + } + }, + { + "name": "ImGuiDeactivatedItemData", + "original_fully_qualified_name": "ImGuiDeactivatedItemData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1436 + } + }, + { + "name": "ElapseFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1437 + } + }, + { + "name": "HasBeenEditedBefore", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1438 + } + }, + { + "name": "IsAlive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1439 + } + } + ], + "comments": { + "preceding": [ + "// Data used by IsItemDeactivated()/IsItemDeactivatedAfterEdit() functions" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1434 + } + }, + { + "name": "ImGuiPopupData", + "original_fully_qualified_name": "ImGuiPopupData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "PopupId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set on OpenPopup()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1456 + } + }, + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1457 + } + }, + { + "name": "RestoreNavWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Set on OpenPopup(), a NavWindow that will be restored on popup close" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1458 + } + }, + { + "name": "ParentNavLayer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Resolved on BeginPopup(). Actually a ImGuiNavLayer type (declared down below), initialized to -1 which is not part of an enum, but serves well-enough as \"not any of layers\" value" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1459 + } + }, + { + "name": "OpenFrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Set on OpenPopup()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1460 + } + }, + { + "name": "OpenParentId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set on OpenPopup(), we need this to differentiate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1461 + } + }, + { + "name": "OpenPopupPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1462 + } + }, + { + "name": "OpenMousePos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Set on OpenPopup(), copy of mouse position at the time of opening popup" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1463 + } + } + ], + "comments": { + "preceding": [ + "// Storage for popup stacks (g.OpenPopupStack and g.BeginPopupStack)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1454 + } + }, + { + "name": "ImBitArrayForNamedKeys", + "original_fully_qualified_name": "ImBitArrayForNamedKeys", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "__dummy", + "is_array": true, + "array_bounds": "20", + "is_anonymous": false, + "type": { + "declaration": "char[20]", + "description": { + "kind": "Array", + "bounds": "20", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1 + } + }, + { + "name": "ImGuiInputEventMousePos", + "original_fully_qualified_name": "ImGuiInputEventMousePos", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "PosX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1521 + } + }, + { + "name": "PosY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1521 + } + }, + { + "name": "MouseSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMouseSource", + "description": { + "kind": "User", + "name": "ImGuiMouseSource" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1521 + } + } + ], + "comments": { + "preceding": [ + "// FIXME: Structures in the union below need to be declared as anonymous unions appears to be an extension?", + "// Using ImVec2() would fail on Clang 'union member 'MousePos' has a non-trivial default constructor'" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1521 + } + }, + { + "name": "ImGuiInputEventMouseWheel", + "original_fully_qualified_name": "ImGuiInputEventMouseWheel", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "WheelX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1522 + } + }, + { + "name": "WheelY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1522 + } + }, + { + "name": "MouseSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMouseSource", + "description": { + "kind": "User", + "name": "ImGuiMouseSource" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1522 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1522 + } + }, + { + "name": "ImGuiInputEventMouseButton", + "original_fully_qualified_name": "ImGuiInputEventMouseButton", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Button", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1523 + } + }, + { + "name": "Down", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1523 + } + }, + { + "name": "MouseSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMouseSource", + "description": { + "kind": "User", + "name": "ImGuiMouseSource" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1523 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1523 + } + }, + { + "name": "ImGuiInputEventMouseViewport", + "original_fully_qualified_name": "ImGuiInputEventMouseViewport", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "HoveredViewportID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1524 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1524 + } + }, + { + "name": "ImGuiInputEventKey", + "original_fully_qualified_name": "ImGuiInputEventKey", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Key", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1525 + } + }, + { + "name": "Down", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1525 + } + }, + { + "name": "AnalogValue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1525 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1525 + } + }, + { + "name": "ImGuiInputEventText", + "original_fully_qualified_name": "ImGuiInputEventText", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Char", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1526 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1526 + } + }, + { + "name": "ImGuiInputEventAppFocused", + "original_fully_qualified_name": "ImGuiInputEventAppFocused", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Focused", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1527 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1527 + } + }, + { + "name": "ImGuiInputEvent", + "original_fully_qualified_name": "ImGuiInputEvent", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Type", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventType", + "description": { + "kind": "User", + "name": "ImGuiInputEventType" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1531 + } + }, + { + "name": "Source", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputSource", + "description": { + "kind": "User", + "name": "ImGuiInputSource" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1532 + } + }, + { + "name": "EventId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// Unique, sequential increasing integer to identify an event (if you need to correlate them to other data)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1533 + } + }, + { + "name": "__anonymous_type3", + "is_array": false, + "is_anonymous": true, + "type": { + "declaration": "__anonymous_type3", + "description": { + "kind": "User", + "name": "__anonymous_type3" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "AddedByTestEngine", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1544 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1529 + } + }, + { + "name": "__anonymous_type3", + "original_fully_qualified_name": "ImGuiInputEvent::", + "kind": "union", + "by_value": false, + "forward_declaration": false, + "is_anonymous": true, + "fields": [ + { + "name": "MousePos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventMousePos", + "description": { + "kind": "User", + "name": "ImGuiInputEventMousePos" + } + }, + "comments": { + "attached": "// if Type == ImGuiInputEventType_MousePos" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1536 + } + }, + { + "name": "MouseWheel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventMouseWheel", + "description": { + "kind": "User", + "name": "ImGuiInputEventMouseWheel" + } + }, + "comments": { + "attached": "// if Type == ImGuiInputEventType_MouseWheel" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1537 + } + }, + { + "name": "MouseButton", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventMouseButton", + "description": { + "kind": "User", + "name": "ImGuiInputEventMouseButton" + } + }, + "comments": { + "attached": "// if Type == ImGuiInputEventType_MouseButton" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1538 + } + }, + { + "name": "MouseViewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventMouseViewport", + "description": { + "kind": "User", + "name": "ImGuiInputEventMouseViewport" + } + }, + "comments": { + "attached": "// if Type == ImGuiInputEventType_MouseViewport" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1539 + } + }, + { + "name": "Key", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventKey", + "description": { + "kind": "User", + "name": "ImGuiInputEventKey" + } + }, + "comments": { + "attached": "// if Type == ImGuiInputEventType_Key" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1540 + } + }, + { + "name": "Text", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventText", + "description": { + "kind": "User", + "name": "ImGuiInputEventText" + } + }, + "comments": { + "attached": "// if Type == ImGuiInputEventType_Text" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1541 + } + }, + { + "name": "AppFocused", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputEventAppFocused", + "description": { + "kind": "User", + "name": "ImGuiInputEventAppFocused" + } + }, + "comments": { + "attached": "// if Type == ImGuiInputEventType_Focus" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1542 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1534 + } + }, + { + "name": "ImGuiKeyRoutingData", + "original_fully_qualified_name": "ImGuiKeyRoutingData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "NextEntryIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyRoutingIndex", + "description": { + "kind": "User", + "name": "ImGuiKeyRoutingIndex" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1559 + } + }, + { + "name": "Mods", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU16", + "description": { + "kind": "User", + "name": "ImU16" + } + }, + "comments": { + "attached": "// Technically we'd only need 4-bits but for simplify we store ImGuiMod_ values which need 16-bits." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1560 + } + }, + { + "name": "RoutingCurrScore", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// [DEBUG] For debug display" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1561 + } + }, + { + "name": "RoutingNextScore", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Lower is better (0: perfect score)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1562 + } + }, + { + "name": "RoutingCurr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1563 + } + }, + { + "name": "RoutingNext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1564 + } + } + ], + "comments": { + "preceding": [ + "// Routing table entry (sizeof() == 16 bytes)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1557 + } + }, + { + "name": "ImGuiKeyRoutingTable", + "original_fully_qualified_name": "ImGuiKeyRoutingTable", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Index", + "is_array": true, + "array_bounds": "ImGuiKey_NamedKey_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyRoutingIndex[ImGuiKey_NamedKey_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiKey_NamedKey_COUNT", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyRoutingIndex" + } + } + }, + "comments": { + "attached": "// Index of first entry in Entries[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1573 + } + }, + { + "name": "Entries", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiKeyRoutingData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiKeyRoutingData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1574 + } + }, + { + "name": "EntriesNext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiKeyRoutingData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiKeyRoutingData" + } + }, + "comments": { + "attached": "// Double-buffer to avoid reallocation (could use a shared buffer)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1575 + } + } + ], + "comments": { + "preceding": [ + "// Routing table: maintain a desired owner for each possible key-chord (key + mods), and setup owner in NewFrame() when mods are matching.", + "// Stored in main context (1 instance)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1571 + } + }, + { + "name": "ImGuiKeyOwnerData", + "original_fully_qualified_name": "ImGuiKeyOwnerData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "OwnerCurr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1585 + } + }, + { + "name": "OwnerNext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1586 + } + }, + { + "name": "LockThisFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Reading this key requires explicit owner id (until end of frame). Set by ImGuiInputFlags_LockThisFrame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1587 + } + }, + { + "name": "LockUntilRelease", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Reading this key requires explicit owner id (until key is released). Set by ImGuiInputFlags_LockUntilRelease. When this is true LockThisFrame is always true as well." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1588 + } + } + ], + "comments": { + "preceding": [ + "// This extends ImGuiKeyData but only for named keys (legacy keys don't support the new features)", + "// Stored in main context (1 per named key). In the future it might be merged into ImGuiKeyData." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1583 + } + }, + { + "name": "ImGuiListClipperRange", + "original_fully_qualified_name": "ImGuiListClipperRange", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Min", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1642 + } + }, + { + "name": "Max", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1643 + } + }, + { + "name": "PosToIndexConvert", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Begin/End are absolute position (will be converted to indices later)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1644 + } + }, + { + "name": "PosToIndexOffsetMin", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Add to Min after converting to indices" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1645 + } + }, + { + "name": "PosToIndexOffsetMax", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Add to Min after converting to indices" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1646 + } + } + ], + "comments": { + "preceding": [ + "// Note that Max is exclusive, so perhaps should be using a Begin/End convention." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1640 + } + }, + { + "name": "ImGuiListClipperData", + "original_fully_qualified_name": "ImGuiListClipperData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ListClipper", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1655 + } + }, + { + "name": "LossynessOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1656 + } + }, + { + "name": "StepNo", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1657 + } + }, + { + "name": "ItemsFrozen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1658 + } + }, + { + "name": "Ranges", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiListClipperRange", + "description": { + "kind": "User", + "name": "ImVector_ImGuiListClipperRange" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1659 + } + } + ], + "comments": { + "preceding": [ + "// Temporary clipper data, buffers shared/reused between instances" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1653 + } + }, + { + "name": "ImGuiNavItemData", + "original_fully_qualified_name": "ImGuiNavItemData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Init,Move // Best candidate window (result->ItemWindow->RootWindowForNav == request->Window)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1741 + } + }, + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Init,Move // Best candidate item ID" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1742 + } + }, + { + "name": "FocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Init,Move // Best candidate focus scope ID" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1743 + } + }, + { + "name": "RectRel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Init,Move // Best candidate bounding box in window relative space" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1744 + } + }, + { + "name": "ItemFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "comments": { + "attached": "// ????,Move // Best candidate item flags" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1745 + } + }, + { + "name": "DistBox", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Move // Best candidate box distance to current NavId" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1746 + } + }, + { + "name": "DistCenter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Move // Best candidate center distance to current NavId" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1747 + } + }, + { + "name": "DistAxial", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Move // Best candidate axial distance to current NavId" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1748 + } + }, + { + "name": "SelectionUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "//I+Mov // Best candidate SetNextItemSelectionUserData() value. Valid if (ItemFlags & ImGuiItemFlags_HasSelectionUserData)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1749 + } + } + ], + "comments": { + "preceding": [ + "// Storage for navigation query/results" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1739 + } + }, + { + "name": "ImGuiFocusScopeData", + "original_fully_qualified_name": "ImGuiFocusScopeData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1758 + } + }, + { + "name": "WindowID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1759 + } + } + ], + "comments": { + "preceding": [ + "// Storage for PushFocusScope(), g.FocusScopeStack[], g.NavFocusRoute[]" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1756 + } + }, + { + "name": "ImGuiTypingSelectRequest", + "original_fully_qualified_name": "ImGuiTypingSelectRequest", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTypingSelectFlags", + "description": { + "kind": "User", + "name": "ImGuiTypingSelectFlags" + } + }, + "comments": { + "attached": "// Flags passed to GetTypingSelectRequest()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1777 + } + }, + { + "name": "SearchBufferLen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1778 + } + }, + { + "name": "SearchBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Search buffer contents (use full string. unless SingleCharMode is set, in which case use SingleCharSize)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1779 + } + }, + { + "name": "SelectRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when buffer was modified this frame, requesting a selection." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1780 + } + }, + { + "name": "SingleCharMode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Notify when buffer contains same character repeated, to implement special mode. In this situation it preferred to not display any on-screen search indication." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1781 + } + }, + { + "name": "SingleCharSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Length in bytes of first letter codepoint (1 for ascii, 2-4 for UTF-8). If (SearchBufferLen==RepeatCharSize) only 1 letter has been input." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1782 + } + } + ], + "comments": { + "preceding": [ + "// Returned by GetTypingSelectRequest(), designed to eventually be public." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1775 + } + }, + { + "name": "ImGuiTypingSelectState", + "original_fully_qualified_name": "ImGuiTypingSelectState", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Request", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTypingSelectRequest", + "description": { + "kind": "User", + "name": "ImGuiTypingSelectRequest" + } + }, + "comments": { + "attached": "// User-facing data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1788 + } + }, + { + "name": "SearchBuffer", + "is_array": true, + "array_bounds": "64", + "is_anonymous": false, + "type": { + "declaration": "char[64]", + "description": { + "kind": "Array", + "bounds": "64", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "comments": { + "attached": "// Search buffer: no need to make dynamic as this search is very transient." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1789 + } + }, + { + "name": "FocusScope", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1790 + } + }, + { + "name": "LastRequestFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "default_value": "0", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1791 + } + }, + { + "name": "LastRequestTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "default_value": "0.0f", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1792 + } + }, + { + "name": "SingleCharModeLock", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "comments": { + "attached": "// After a certain single char repeat count we lock into SingleCharMode. Two benefits: 1) buffer never fill, 2) we can provide an immediate SingleChar mode without timer elapsing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1793 + } + } + ], + "comments": { + "preceding": [ + "// Storage for GetTypingSelectRequest()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1786 + } + }, + { + "name": "ImGuiOldColumnData", + "original_fully_qualified_name": "ImGuiOldColumnData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "OffsetNorm", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Column start offset, normalized 0.0 (far left) -> 1.0 (far right)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1826 + } + }, + { + "name": "OffsetNormBeforeResize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1827 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiOldColumnFlags", + "description": { + "kind": "User", + "name": "ImGuiOldColumnFlags" + } + }, + "comments": { + "attached": "// Not exposed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1828 + } + }, + { + "name": "ClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1829 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1824 + } + }, + { + "name": "ImGuiOldColumns", + "original_fully_qualified_name": "ImGuiOldColumns", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1836 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiOldColumnFlags", + "description": { + "kind": "User", + "name": "ImGuiOldColumnFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1837 + } + }, + { + "name": "IsFirstFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1838 + } + }, + { + "name": "IsBeingResized", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1839 + } + }, + { + "name": "Current", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1840 + } + }, + { + "name": "Count", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1841 + } + }, + { + "name": "OffMinX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Offsets from HostWorkRect.Min.x" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1842 + } + }, + { + "name": "OffMaxX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Offsets from HostWorkRect.Min.x" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1842 + } + }, + { + "name": "LineMinY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1843 + } + }, + { + "name": "LineMaxY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1843 + } + }, + { + "name": "HostCursorPosY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Backup of CursorPos at the time of BeginColumns()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1844 + } + }, + { + "name": "HostCursorMaxPosX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Backup of CursorMaxPos at the time of BeginColumns()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1845 + } + }, + { + "name": "HostInitialClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Backup of ClipRect at the time of BeginColumns()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1846 + } + }, + { + "name": "HostBackupClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Backup of ClipRect during PushColumnsBackground()/PopColumnsBackground()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1847 + } + }, + { + "name": "HostBackupParentWorkRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "//Backup of WorkRect at the time of BeginColumns()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1848 + } + }, + { + "name": "Columns", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiOldColumnData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiOldColumnData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1849 + } + }, + { + "name": "Splitter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListSplitter", + "description": { + "kind": "User", + "name": "ImDrawListSplitter" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1850 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1834 + } + }, + { + "name": "ImGuiBoxSelectState", + "original_fully_qualified_name": "ImGuiBoxSelectState", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// Active box-selection data (persistent, 1 active at a time)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1862 + } + }, + { + "name": "IsActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1863 + } + }, + { + "name": "IsStarting", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1864 + } + }, + { + "name": "IsStartedFromVoid", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Starting click was not from an item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1865 + } + }, + { + "name": "IsStartedSetNavIdOnce", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1866 + } + }, + { + "name": "RequestClear", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1867 + } + }, + { + "name": "KeyMods", + "is_array": false, + "width": 16, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "attached": "// Latched key-mods for box-select logic." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1868 + } + }, + { + "name": "StartPosRel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Start position in window-contents relative space (to support scrolling)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1869 + } + }, + { + "name": "EndPosRel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// End position in window-contents relative space" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1870 + } + }, + { + "name": "ScrollAccum", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Scrolling accumulator (to behave at high-frame spaces)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1871 + } + }, + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1872 + } + }, + { + "name": "UnclipMode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Temporary/Transient data" + ], + "attached": "// (Temp/Transient, here in hot area). Set/cleared by the BeginMultiSelect()/EndMultiSelect() owning active box-select." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1875 + } + }, + { + "name": "UnclipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Rectangle where ItemAdd() clipping may be temporarily disabled. Need support by multi-select supporting widgets." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1876 + } + }, + { + "name": "BoxSelectRectPrev", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Selection rectangle in absolute coordinates (derived every frame from BoxSelectStartPosRel and MousePos)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1877 + } + }, + { + "name": "BoxSelectRectCurr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1878 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1859 + } + }, + { + "name": "ImGuiMultiSelectTempData", + "original_fully_qualified_name": "ImGuiMultiSelectTempData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "IO", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMultiSelectIO", + "description": { + "kind": "User", + "name": "ImGuiMultiSelectIO" + } + }, + "comments": { + "attached": "// MUST BE FIRST FIELD. Requests are set and returned by BeginMultiSelect()/EndMultiSelect() + written to by user during the loop." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1893 + } + }, + { + "name": "Storage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMultiSelectState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectState" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1894 + } + }, + { + "name": "FocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Copied from g.CurrentFocusScopeId (unless another selection scope was pushed manually)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1895 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMultiSelectFlags", + "description": { + "kind": "User", + "name": "ImGuiMultiSelectFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1896 + } + }, + { + "name": "ScopeRectMin", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1897 + } + }, + { + "name": "BackupCursorMaxPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1898 + } + }, + { + "name": "LastSubmittedItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// Copy of last submitted item data, used to merge output ranges." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1899 + } + }, + { + "name": "BoxSelectId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1900 + } + }, + { + "name": "KeyMods", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1901 + } + }, + { + "name": "LoopRequestSetAll", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// -1: no operation, 0: clear all, 1: select all." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1902 + } + }, + { + "name": "IsEndIO", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when switching IO from BeginMultiSelect() to EndMultiSelect() state." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1903 + } + }, + { + "name": "IsFocused", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set if currently focusing the selection scope (any item of the selection). May be used if you have custom shortcut associated to selection." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1904 + } + }, + { + "name": "IsKeyboardSetRange", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set by BeginMultiSelect() when using Shift+Navigation. Because scrolling may be affected we can't afford a frame of lag with Shift+Navigation." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1905 + } + }, + { + "name": "NavIdPassedBy", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1906 + } + }, + { + "name": "RangeSrcPassedBy", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set by the item that matches RangeSrcItem." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1907 + } + }, + { + "name": "RangeDstPassedBy", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set by the item that matches NavJustMovedToId when IsSetRange is set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1908 + } + } + ], + "comments": { + "preceding": [ + "// Temporary storage for multi-select" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1891 + } + }, + { + "name": "ImGuiMultiSelectState", + "original_fully_qualified_name": "ImGuiMultiSelectState", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1918 + } + }, + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1919 + } + }, + { + "name": "LastFrameActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last used frame-count, for GC." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1920 + } + }, + { + "name": "LastSelectionSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Set by BeginMultiSelect() based on optional info provided by user. May be -1 if unknown." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1921 + } + }, + { + "name": "RangeSelected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// -1 (don't have) or true/false" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1922 + } + }, + { + "name": "NavIdSelected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// -1 (don't have) or true/false" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1923 + } + }, + { + "name": "RangeSrcItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "//" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1924 + } + }, + { + "name": "NavIdItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// SetNextItemSelectionUserData() value for NavId (if part of submitted items)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1925 + } + } + ], + "comments": { + "preceding": [ + "// Persistent storage for multi-select (as long as selection is alive)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1916 + } + }, + { + "name": "ImGuiDockNode", + "original_fully_qualified_name": "ImGuiDockNode", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1990 + } + }, + { + "name": "SharedFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "comments": { + "attached": "// (Write) Flags shared by all nodes of a same dockspace hierarchy (inherited from the root node)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1991 + } + }, + { + "name": "LocalFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "comments": { + "attached": "// (Write) Flags specific to this node" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1992 + } + }, + { + "name": "LocalFlagsInWindows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "comments": { + "attached": "// (Write) Flags specific to this node, applied from windows" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1993 + } + }, + { + "name": "MergedFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "comments": { + "attached": "// (Read) Effective flags (== SharedFlags | LocalFlagsInNode | LocalFlagsInWindows)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1994 + } + }, + { + "name": "State", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNodeState", + "description": { + "kind": "User", + "name": "ImGuiDockNodeState" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1995 + } + }, + { + "name": "ParentNode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1996 + } + }, + { + "name": "ChildNodes", + "is_array": true, + "array_bounds": "2", + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNode*[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + } + }, + "comments": { + "attached": "// [Split node only] Child nodes (left/right or top/bottom). Consider switching to an array." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1997 + } + }, + { + "name": "Windows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiWindowPtr", + "description": { + "kind": "User", + "name": "ImVector_ImGuiWindowPtr" + } + }, + "comments": { + "attached": "// Note: unordered list! Iterate TabBar->Tabs for user-order." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1998 + } + }, + { + "name": "TabBar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1999 + } + }, + { + "name": "Pos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Current position" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2000 + } + }, + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Current size" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2001 + } + }, + { + "name": "SizeRef", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// [Split node only] Last explicitly written-to size (overridden when using a splitter affecting the node), used to calculate Size." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2002 + } + }, + { + "name": "SplitAxis", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "comments": { + "attached": "// [Split node only] Split axis (X or Y)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2003 + } + }, + { + "name": "WindowClass", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowClass", + "description": { + "kind": "User", + "name": "ImGuiWindowClass" + } + }, + "comments": { + "attached": "// [Root node only]" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2004 + } + }, + { + "name": "LastBgColor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2005 + } + }, + { + "name": "HostWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2007 + } + }, + { + "name": "VisibleWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Generally point to window which is ID is == SelectedTabID, but when CTRL+Tabbing this can be a different window." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2008 + } + }, + { + "name": "CentralNode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "comments": { + "attached": "// [Root node only] Pointer to central node." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2009 + } + }, + { + "name": "OnlyNodeWithWindows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "comments": { + "attached": "// [Root node only] Set when there is a single visible node within the hierarchy." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2010 + } + }, + { + "name": "CountNodeWithWindows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// [Root node only]" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2011 + } + }, + { + "name": "LastFrameAlive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last frame number the node was updated or kept alive explicitly with DockSpace() + ImGuiDockNodeFlags_KeepAliveOnly" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2012 + } + }, + { + "name": "LastFrameActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last frame number the node was updated." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2013 + } + }, + { + "name": "LastFrameFocused", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last frame number the node was focused." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2014 + } + }, + { + "name": "LastFocusedNodeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// [Root node only] Which of our child docking node (any ancestor in the hierarchy) was last focused." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2015 + } + }, + { + "name": "SelectedTabId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// [Leaf node only] Which of our tab/window is selected." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2016 + } + }, + { + "name": "WantCloseTabId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// [Leaf node only] Set when closing a specific tab/window." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2017 + } + }, + { + "name": "RefViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Reference viewport ID from visible window when HostWindow == NULL." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2018 + } + }, + { + "name": "AuthorityForPos", + "is_array": false, + "width": 3, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataAuthority", + "description": { + "kind": "User", + "name": "ImGuiDataAuthority" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2019 + } + }, + { + "name": "AuthorityForSize", + "is_array": false, + "width": 3, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataAuthority", + "description": { + "kind": "User", + "name": "ImGuiDataAuthority" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2020 + } + }, + { + "name": "AuthorityForViewport", + "is_array": false, + "width": 3, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataAuthority", + "description": { + "kind": "User", + "name": "ImGuiDataAuthority" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2021 + } + }, + { + "name": "IsVisible", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to false when the node is hidden (usually disabled as it has no active window)" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2022 + } + }, + { + "name": "IsFocused", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2023 + } + }, + { + "name": "IsBgDrawnThisFrame", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2024 + } + }, + { + "name": "HasCloseButton", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Provide space for a close button (if any of the docked window has one). Note that button may be hidden on window without one." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2025 + } + }, + { + "name": "HasWindowMenuButton", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2026 + } + }, + { + "name": "HasCentralNodeChild", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2027 + } + }, + { + "name": "WantCloseAll", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when closing all tabs at once." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2028 + } + }, + { + "name": "WantLockSizeOnce", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2029 + } + }, + { + "name": "WantMouseMove", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// After a node extraction we need to transition toward moving the newly created host window" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2030 + } + }, + { + "name": "WantHiddenTabBarUpdate", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2031 + } + }, + { + "name": "WantHiddenTabBarToggle", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2032 + } + } + ], + "comments": { + "preceding": [ + "// sizeof() 156~192" + ] + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1988 + } + }, + { + "name": "ImGuiWindowDockStyle", + "original_fully_qualified_name": "ImGuiWindowDockStyle", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Colors", + "is_array": true, + "array_bounds": "ImGuiWindowDockStyleCol_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImU32[ImGuiWindowDockStyleCol_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiWindowDockStyleCol_COUNT", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2071 + } + } + ], + "comments": { + "preceding": [ + "// We don't store style.Alpha: dock_node->LastBgColor embeds it and otherwise it would only affect the docking tab, which intuitively I would say we don't want to." + ] + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2069 + } + }, + { + "name": "ImGuiDockContext", + "original_fully_qualified_name": "ImGuiDockContext", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Nodes", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// Map ID -> ImGuiDockNode*: Active nodes" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2076 + } + }, + { + "name": "Requests", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiDockRequest", + "description": { + "kind": "User", + "name": "ImVector_ImGuiDockRequest" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2077 + } + }, + { + "name": "NodesSettings", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiDockNodeSettings", + "description": { + "kind": "User", + "name": "ImVector_ImGuiDockNodeSettings" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2078 + } + }, + { + "name": "WantFullRebuild", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2079 + } + } + ], + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2074 + } + }, + { + "name": "ImGuiViewportP", + "original_fully_qualified_name": "ImGuiViewportP", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// Appended from parent type ImGuiViewport" + ], + "attached": "// Unique identifier for the viewport" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4012 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportFlags", + "description": { + "kind": "User", + "name": "ImGuiViewportFlags" + } + }, + "comments": { + "attached": "// See ImGuiViewportFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4013 + } + }, + { + "name": "Pos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Main Area: Position of the viewport (Dear ImGui coordinates are the same as OS desktop/native coordinates)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4014 + } + }, + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Main Area: Size of the viewport." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4015 + } + }, + { + "name": "FramebufferScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Density of the viewport for Retina display (always 1,1 on Windows, may be 2,2 etc on macOS/iOS). This will affect font rasterizer density." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4016 + } + }, + { + "name": "WorkPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Work Area: Position of the viewport minus task bars, menus bars, status bars (>= Pos)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4017 + } + }, + { + "name": "WorkSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Work Area: Size of the viewport minus task bars, menu bars, status bars (<= Size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4018 + } + }, + { + "name": "DpiScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 1.0f = 96 DPI = No extra scale." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4019 + } + }, + { + "name": "ParentViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// (Advanced) 0: no parent. Instruct the platform backend to setup a parent/child relationship between platform windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4020 + } + }, + { + "name": "DrawData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "comments": { + "attached": "// The ImDrawData corresponding to this viewport. Valid after Render() and until the next call to NewFrame()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4021 + } + }, + { + "name": "RendererUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "preceding": [ + "// Platform/Backend Dependent Data", + "// Our design separate the Renderer and Platform backends to facilitate combining default backends with each others.", + "// When our create your own backend for a custom engine, it is possible that both Renderer and Platform will be handled", + "// by the same system and you may not need to use all the UserData/Handle fields.", + "// The library never uses those fields, they are merely storage to facilitate backend implementation." + ], + "attached": "// void* to hold custom data structure for the renderer (e.g. swap chain, framebuffers etc.). generally set by your Renderer_CreateWindow function." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4028 + } + }, + { + "name": "PlatformUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// void* to hold custom data structure for the OS / platform (e.g. windowing info, render context). generally set by your Platform_CreateWindow function." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4029 + } + }, + { + "name": "PlatformHandle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// void* to hold higher-level, platform window handle (e.g. HWND for Win32 backend, Uint32 WindowID for SDL, GLFWWindow* for GLFW), for FindViewportByPlatformHandle()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4030 + } + }, + { + "name": "PlatformHandleRaw", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// void* to hold lower-level, platform-native window handle (always HWND on Win32 platform, unused for other platforms)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4031 + } + }, + { + "name": "PlatformWindowCreated", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window has been created (Platform_CreateWindow() has been called). This is false during the first frame where a viewport is being created." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4032 + } + }, + { + "name": "PlatformRequestMove", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window requested move (e.g. window was moved by the OS / host window manager, authoritative position will be OS window position)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4033 + } + }, + { + "name": "PlatformRequestResize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window requested resize (e.g. window was resized by the OS / host window manager, authoritative size will be OS window size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4034 + } + }, + { + "name": "PlatformRequestClose", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window requested closure (e.g. window was moved by the OS / host window manager, e.g. pressing ALT-F4)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4035 + } + }, + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Set when the viewport is owned by a window (and ImGuiViewportFlags_CanHostOtherWindows is NOT set)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2093 + } + }, + { + "name": "Idx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2094 + } + }, + { + "name": "LastFrameActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last frame number this viewport was activated by a window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2095 + } + }, + { + "name": "LastFocusedStampCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last stamp number from when a window hosted by this viewport was focused (by comparing this value between two viewport we have an implicit viewport z-order we use as fallback)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2096 + } + }, + { + "name": "LastNameHash", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2097 + } + }, + { + "name": "LastPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2098 + } + }, + { + "name": "LastSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2099 + } + }, + { + "name": "Alpha", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Window opacity (when dragging dockable windows/viewports we make them transparent)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2100 + } + }, + { + "name": "LastAlpha", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2101 + } + }, + { + "name": "LastFocusedHadNavWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Instead of maintaining a LastFocusedWindow (which may harder to correctly maintain), we merely store weither NavWindow != NULL last time the viewport was focused." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2102 + } + }, + { + "name": "PlatformMonitor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2103 + } + }, + { + "name": "BgFgDrawListsLastFrame", + "is_array": true, + "array_bounds": "2", + "is_anonymous": false, + "type": { + "declaration": "int[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "comments": { + "attached": "// Last frame number the background (0) and foreground (1) draw lists were used" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2104 + } + }, + { + "name": "BgFgDrawLists", + "is_array": true, + "array_bounds": "2", + "is_anonymous": false, + "type": { + "declaration": "ImDrawList*[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + } + }, + "comments": { + "attached": "// Convenience background (0) and foreground (1) draw lists. We use them to draw software mouser cursor when io.MouseDrawCursor is set and to draw most debug overlays." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2105 + } + }, + { + "name": "DrawDataP", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawData", + "description": { + "kind": "User", + "name": "ImDrawData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2106 + } + }, + { + "name": "DrawDataBuilder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawDataBuilder", + "description": { + "kind": "User", + "name": "ImDrawDataBuilder" + } + }, + "comments": { + "attached": "// Temporary data while building final ImDrawData" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2107 + } + }, + { + "name": "LastPlatformPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2108 + } + }, + { + "name": "LastPlatformSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2109 + } + }, + { + "name": "LastRendererSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2110 + } + }, + { + "name": "WorkInsetMin", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "preceding": [ + "// Per-viewport work area", + "// - Insets are >= 0.0f values, distance from viewport corners to work area.", + "// - BeginMainMenuBar() and DockspaceOverViewport() tend to use work area to avoid stepping over existing contents.", + "// - Generally 'safeAreaInsets' in iOS land, 'DisplayCutout' in Android land." + ], + "attached": "// Work Area inset locked for the frame. GetWorkRect() always fits within GetMainRect()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2116 + } + }, + { + "name": "WorkInsetMax", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2117 + } + }, + { + "name": "BuildWorkInsetMin", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Work Area inset accumulator for current frame, to become next frame's WorkInset" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2118 + } + }, + { + "name": "BuildWorkInsetMax", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2119 + } + } + ], + "comments": { + "preceding": [ + "// ImGuiViewport Private/Internals fields (cardinal sin: we are using inheritance!)", + "// Every instance of ImGuiViewport is in fact a ImGuiViewportP." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2091 + } + }, + { + "name": "ImGuiWindowSettings", + "original_fully_qualified_name": "ImGuiWindowSettings", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2145 + } + }, + { + "name": "Pos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2ih", + "description": { + "kind": "User", + "name": "ImVec2ih" + } + }, + "comments": { + "attached": "// NB: Settings position are stored RELATIVE to the viewport! Whereas runtime ones are absolute positions." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2146 + } + }, + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2ih", + "description": { + "kind": "User", + "name": "ImVec2ih" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2147 + } + }, + { + "name": "ViewportPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2ih", + "description": { + "kind": "User", + "name": "ImVec2ih" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2148 + } + }, + { + "name": "ViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2149 + } + }, + { + "name": "DockId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID of last known DockNode (even if the DockNode is invisible because it has only 1 active window), or 0 if none." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2150 + } + }, + { + "name": "ClassId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID of window class if specified" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2151 + } + }, + { + "name": "DockOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Order of the last time the window was visible within its DockNode. This is used to reorder windows that are reappearing on the same frame. Same value between windows that were active and windows that were none are possible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2152 + } + }, + { + "name": "Collapsed", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2153 + } + }, + { + "name": "IsChild", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2154 + } + }, + { + "name": "WantApply", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2155 + } + }, + { + "name": "WantDelete", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to invalidate/delete the settings entry" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2156 + } + } + ], + "comments": { + "preceding": [ + "// Windows data saved in imgui.ini file", + "// Because we never destroy or rename ImGuiWindowSettings, we can store the names in a separate buffer easily.", + "// (this is designed to be stored in a ImChunkStream buffer, with the variable-length Name following our structure)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2143 + } + }, + { + "name": "ImGuiSettingsHandler", + "original_fully_qualified_name": "ImGuiSettingsHandler", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "TypeName", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Short description stored in .ini file. Disallowed characters: '[' ']'" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2164 + } + }, + { + "name": "TypeHash", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// == ImHashStr(TypeName)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2165 + } + }, + { + "name": "ClearAllFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*ClearAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "handler", + "type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ClearAllFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "handler", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Clear all settings data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ReadInitFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*ReadInitFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "handler", + "type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ReadInitFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "handler", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Read: Called before reading (in registration order)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ReadOpenFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void* (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "handler", + "type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ReadOpenFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "handler", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + { + "kind": "Type", + "name": "name", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Read: Called when entering into a new ini entry e.g. \"[Window][Name]\"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ReadLineFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "handler", + "type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "entry", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "line", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ReadLineFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "handler", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + { + "kind": "Type", + "name": "entry", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "line", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Read: Called for every line of text within an ini entry" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "ApplyAllFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*ApplyAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "handler", + "type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ApplyAllFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "handler", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Read: Called after reading (in registration order)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "WriteAllFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "handler", + "type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_buf", + "type": { + "declaration": "ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "WriteAllFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "handler", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + { + "kind": "Type", + "name": "out_buf", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Write: Output every entries into 'out_buf'" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2172 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2162 + } + }, + { + "name": "ImGuiLocEntry", + "original_fully_qualified_name": "ImGuiLocEntry", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Key", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiLocKey", + "description": { + "kind": "User", + "name": "ImGuiLocKey" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2202 + } + }, + { + "name": "Text", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2203 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2200 + } + }, + { + "name": "ImGuiDebugAllocEntry", + "original_fully_qualified_name": "ImGuiDebugAllocEntry", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "FrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + }, + { + "name": "AllocCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2252 + } + }, + { + "name": "FreeCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2253 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "ImGuiDebugAllocInfo", + "original_fully_qualified_name": "ImGuiDebugAllocInfo", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "TotalAllocCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of call to MemAlloc()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2258 + } + }, + { + "name": "TotalFreeCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2259 + } + }, + { + "name": "LastEntriesIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Current index in buffer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2260 + } + }, + { + "name": "LastEntriesBuf", + "is_array": true, + "array_bounds": "6", + "is_anonymous": false, + "type": { + "declaration": "ImGuiDebugAllocEntry[6]", + "description": { + "kind": "Array", + "bounds": "6", + "inner_type": { + "kind": "User", + "name": "ImGuiDebugAllocEntry" + } + } + }, + "comments": { + "attached": "// Track last 6 frames that had allocations" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2261 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2256 + } + }, + { + "name": "ImGuiMetricsConfig", + "original_fully_qualified_name": "ImGuiMetricsConfig", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ShowDebugLog", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2268 + } + }, + { + "name": "ShowIDStackTool", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2269 + } + }, + { + "name": "ShowWindowsRects", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2270 + } + }, + { + "name": "ShowWindowsBeginOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2271 + } + }, + { + "name": "ShowTablesRects", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2272 + } + }, + { + "name": "ShowDrawCmdMesh", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "true", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2273 + } + }, + { + "name": "ShowDrawCmdBoundingBoxes", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "true", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2274 + } + }, + { + "name": "ShowTextEncodingViewer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2275 + } + }, + { + "name": "ShowTextureUsedRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2276 + } + }, + { + "name": "ShowDockingNodes", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "false", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2277 + } + }, + { + "name": "ShowWindowsRectsType", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "default_value": "-1", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2278 + } + }, + { + "name": "ShowTablesRectsType", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "default_value": "-1", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2279 + } + }, + { + "name": "HighlightMonitorIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "default_value": "-1", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2280 + } + }, + { + "name": "HighlightViewportID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "default_value": "0", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2281 + } + }, + { + "name": "ShowFontPreview", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "default_value": "true", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2282 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2266 + } + }, + { + "name": "ImGuiStackLevelInfo", + "original_fully_qualified_name": "ImGuiStackLevelInfo", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2287 + } + }, + { + "name": "QueryFrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// >= 1: Query in progress" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2288 + } + }, + { + "name": "QuerySuccess", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Obtained result from DebugHookIdInfo()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2289 + } + }, + { + "name": "DataType", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2290 + } + }, + { + "name": "Desc", + "is_array": true, + "array_bounds": "57", + "is_anonymous": false, + "type": { + "declaration": "char[57]", + "description": { + "kind": "Array", + "bounds": "57", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "comments": { + "attached": "// Arbitrarily sized buffer to hold a result (FIXME: could replace Results[] with a chunk stream?) FIXME: Now that we added CTRL+C this should be fixed." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2291 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2285 + } + }, + { + "name": "ImGuiIDStackTool", + "original_fully_qualified_name": "ImGuiIDStackTool", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "LastActiveFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2299 + } + }, + { + "name": "StackLevel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -1: query stack and resize Results, >= 0: individual stack level" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2300 + } + }, + { + "name": "QueryId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID to query details for" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2301 + } + }, + { + "name": "Results", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiStackLevelInfo", + "description": { + "kind": "User", + "name": "ImVector_ImGuiStackLevelInfo" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2302 + } + }, + { + "name": "CopyToClipboardOnCtrlC", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2303 + } + }, + { + "name": "CopyToClipboardLastTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2304 + } + }, + { + "name": "ResultPathBuf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextBuffer", + "description": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2305 + } + } + ], + "comments": { + "preceding": [ + "// State for ID Stack tool queries" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2297 + } + }, + { + "name": "ImGuiContextHook", + "original_fully_qualified_name": "ImGuiContextHook", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "HookId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// A unique ID assigned by AddContextHook()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2319 + } + }, + { + "name": "Type", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContextHookType", + "description": { + "kind": "User", + "name": "ImGuiContextHookType" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2320 + } + }, + { + "name": "Owner", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2321 + } + }, + { + "name": "Callback", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContextHookCallback", + "description": { + "kind": "User", + "name": "ImGuiContextHookCallback" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2322 + } + }, + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2323 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2317 + } + }, + { + "name": "ImGuiContext", + "original_fully_qualified_name": "ImGuiContext", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Initialized", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2334 + } + }, + { + "name": "IO", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiIO", + "description": { + "kind": "User", + "name": "ImGuiIO" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2335 + } + }, + { + "name": "PlatformIO", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPlatformIO", + "description": { + "kind": "User", + "name": "ImGuiPlatformIO" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2336 + } + }, + { + "name": "Style", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStyle", + "description": { + "kind": "User", + "name": "ImGuiStyle" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2337 + } + }, + { + "name": "ConfigFlagsCurrFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiConfigFlags", + "description": { + "kind": "User", + "name": "ImGuiConfigFlags" + } + }, + "comments": { + "attached": "// = g.IO.ConfigFlags at the time of NewFrame()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2338 + } + }, + { + "name": "ConfigFlagsLastFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiConfigFlags", + "description": { + "kind": "User", + "name": "ImGuiConfigFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2339 + } + }, + { + "name": "FontAtlases", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontAtlasPtr", + "description": { + "kind": "User", + "name": "ImVector_ImFontAtlasPtr" + } + }, + "comments": { + "attached": "// List of font atlases used by the context (generally only contains g.IO.Fonts aka the main font atlas)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2340 + } + }, + { + "name": "Font", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "comments": { + "attached": "// Currently bound font. (== FontStack.back().Font)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2341 + } + }, + { + "name": "FontBaked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "comments": { + "attached": "// Currently bound font at currently bound size. (== Font->GetFontBaked(FontSize))" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2342 + } + }, + { + "name": "FontSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Currently bound font size == line height (== FontSizeBase + externals scales applied in the UpdateCurrentFontSize() function)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2343 + } + }, + { + "name": "FontSizeBase", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Font size before scaling == style.FontSizeBase == value passed to PushFont() when specified." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2344 + } + }, + { + "name": "FontBakedScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// == FontBaked->Size / FontSize. Scale factor over baked size. Rarely used nowadays, very often == 1.0f." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2345 + } + }, + { + "name": "FontRasterizerDensity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Current font density. Used by all calls to GetFontBaked()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2346 + } + }, + { + "name": "CurrentDpiScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Current window/viewport DpiScale == CurrentViewport->DpiScale" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2347 + } + }, + { + "name": "DrawListSharedData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListSharedData", + "description": { + "kind": "User", + "name": "ImDrawListSharedData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2348 + } + }, + { + "name": "Time", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2349 + } + }, + { + "name": "FrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2350 + } + }, + { + "name": "FrameCountEnded", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2351 + } + }, + { + "name": "FrameCountPlatformEnded", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2352 + } + }, + { + "name": "FrameCountRendered", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2353 + } + }, + { + "name": "WithinEndChildID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set within EndChild()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2354 + } + }, + { + "name": "WithinFrameScope", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set by NewFrame(), cleared by EndFrame()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2355 + } + }, + { + "name": "WithinFrameScopeWithImplicitWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set by NewFrame(), cleared by EndFrame() when the implicit debug window has been pushed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2356 + } + }, + { + "name": "GcCompactAll", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Request full GC" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2357 + } + }, + { + "name": "TestEngineHookItems", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Will call test engine hooks: ImGuiTestEngineHook_ItemAdd(), ImGuiTestEngineHook_ItemInfo(), ImGuiTestEngineHook_Log()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2358 + } + }, + { + "name": "TestEngine", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Test engine user data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2359 + } + }, + { + "name": "ContextName", + "is_array": true, + "array_bounds": "16", + "is_anonymous": false, + "type": { + "declaration": "char[16]", + "description": { + "kind": "Array", + "bounds": "16", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "comments": { + "attached": "// Storage for a context name (to facilitate debugging multi-context setups)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2360 + } + }, + { + "name": "InputEventsQueue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiInputEvent", + "description": { + "kind": "User", + "name": "ImVector_ImGuiInputEvent" + } + }, + "comments": { + "preceding": [ + "// Inputs" + ], + "attached": "// Input events which will be trickled/written into IO structure." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2363 + } + }, + { + "name": "InputEventsTrail", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiInputEvent", + "description": { + "kind": "User", + "name": "ImVector_ImGuiInputEvent" + } + }, + "comments": { + "attached": "// Past input events processed in NewFrame(). This is to allow domain-specific application to access e.g mouse/pen trail." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2364 + } + }, + { + "name": "InputEventsNextMouseSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMouseSource", + "description": { + "kind": "User", + "name": "ImGuiMouseSource" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2365 + } + }, + { + "name": "InputEventsNextEventId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2366 + } + }, + { + "name": "Windows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiWindowPtr", + "description": { + "kind": "User", + "name": "ImVector_ImGuiWindowPtr" + } + }, + "comments": { + "preceding": [ + "// Windows state" + ], + "attached": "// Windows, sorted in display order, back to front" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2369 + } + }, + { + "name": "WindowsFocusOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiWindowPtr", + "description": { + "kind": "User", + "name": "ImVector_ImGuiWindowPtr" + } + }, + "comments": { + "attached": "// Root windows, sorted in focus order, back to front." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2370 + } + }, + { + "name": "WindowsTempSortBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiWindowPtr", + "description": { + "kind": "User", + "name": "ImVector_ImGuiWindowPtr" + } + }, + "comments": { + "attached": "// Temporary buffer used in EndFrame() to reorder windows so parents are kept before their child" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2371 + } + }, + { + "name": "CurrentWindowStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiWindowStackData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiWindowStackData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2372 + } + }, + { + "name": "WindowsById", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// Map window's ImGuiID to ImGuiWindow*" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2373 + } + }, + { + "name": "WindowsActiveCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of unique windows submitted by frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2374 + } + }, + { + "name": "WindowsBorderHoverPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Padding around resizable windows for which hovering on counts as hovering the window == ImMax(style.TouchExtraPadding, style.WindowBorderHoverPadding). This isn't so multi-dpi friendly." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2375 + } + }, + { + "name": "DebugBreakInWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set to break in Begin() call." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2376 + } + }, + { + "name": "CurrentWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Window being drawn into" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2377 + } + }, + { + "name": "HoveredWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Window the mouse is hovering. Will typically catch mouse inputs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2378 + } + }, + { + "name": "HoveredWindowUnderMovingWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Hovered window ignoring MovingWindow. Only set if MovingWindow is set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2379 + } + }, + { + "name": "HoveredWindowBeforeClear", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Window the mouse is hovering. Filled even with _NoMouse. This is currently useful for multi-context compositors." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2380 + } + }, + { + "name": "MovingWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Track the window we clicked on (in order to preserve focus). The actual window that is moved is generally MovingWindow->RootWindowDockTree." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2381 + } + }, + { + "name": "WheelingWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Track the window we started mouse-wheeling on. Until a timer elapse or mouse has moved, generally keep scrolling the same window even if during the course of scrolling the mouse ends up hovering a child window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2382 + } + }, + { + "name": "WheelingWindowRefMousePos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2383 + } + }, + { + "name": "WheelingWindowStartFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// This may be set one frame before WheelingWindow is != NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2384 + } + }, + { + "name": "WheelingWindowScrolledFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2385 + } + }, + { + "name": "WheelingWindowReleaseTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2386 + } + }, + { + "name": "WheelingWindowWheelRemainder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2387 + } + }, + { + "name": "WheelingAxisAvg", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2388 + } + }, + { + "name": "DebugDrawIdConflictsId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// Item/widgets state and tracking information" + ], + "attached": "// Set when we detect multiple items with the same identifier" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2391 + } + }, + { + "name": "DebugHookIdInfo", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Will call core hooks: DebugHookIdInfo() from GetID functions, used by ID Stack Tool [next HoveredId/ActiveId to not pull in an extra cache-line]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2392 + } + }, + { + "name": "HoveredId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Hovered widget, filled during the frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2393 + } + }, + { + "name": "HoveredIdPreviousFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2394 + } + }, + { + "name": "HoveredIdPreviousFrameItemCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Count numbers of items using the same ID as last frame's hovered id" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2395 + } + }, + { + "name": "HoveredIdTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Measure contiguous hovering time" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2396 + } + }, + { + "name": "HoveredIdNotActiveTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Measure contiguous hovering time where the item has not been active" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2397 + } + }, + { + "name": "HoveredIdAllowOverlap", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2398 + } + }, + { + "name": "HoveredIdIsDisabled", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// At least one widget passed the rect test, but has been discarded by disabled flag or popup inhibit. May be true even if HoveredId == 0." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2399 + } + }, + { + "name": "ItemUnclipByLog", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Disable ItemAdd() clipping, essentially a memory-locality friendly copy of LogEnabled" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2400 + } + }, + { + "name": "ActiveId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Active widget" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2401 + } + }, + { + "name": "ActiveIdIsAlive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Active widget has been seen this frame (we can't use a bool as the ActiveId may change within the frame)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2402 + } + }, + { + "name": "ActiveIdTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2403 + } + }, + { + "name": "ActiveIdIsJustActivated", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set at the time of activation for one frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2404 + } + }, + { + "name": "ActiveIdAllowOverlap", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2405 + } + }, + { + "name": "ActiveIdNoClearOnFocusLoss", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Disable losing active id if the active id window gets unfocused." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2406 + } + }, + { + "name": "ActiveIdHasBeenPressedBefore", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Track whether the active id led to a press (this is to allow changing between PressOnClick and PressOnRelease without pressing twice). Used by range_select branch." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2407 + } + }, + { + "name": "ActiveIdHasBeenEditedBefore", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Was the value associated to the widget Edited over the course of the Active state." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2408 + } + }, + { + "name": "ActiveIdHasBeenEditedThisFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2409 + } + }, + { + "name": "ActiveIdFromShortcut", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2410 + } + }, + { + "name": "ActiveIdDisabledId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// When clicking a disabled item we set ActiveId=window->MoveId to avoid interference with widget code. Actual item ID is stored here." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2411 + } + }, + { + "name": "ActiveIdMouseButton", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2412 + } + }, + { + "name": "ActiveIdClickOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2413 + } + }, + { + "name": "ActiveIdWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2414 + } + }, + { + "name": "ActiveIdSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputSource", + "description": { + "kind": "User", + "name": "ImGuiInputSource" + } + }, + "comments": { + "attached": "// Activating source: ImGuiInputSource_Mouse OR ImGuiInputSource_Keyboard OR ImGuiInputSource_Gamepad" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2415 + } + }, + { + "name": "ActiveIdPreviousFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2416 + } + }, + { + "name": "DeactivatedItemData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDeactivatedItemData", + "description": { + "kind": "User", + "name": "ImGuiDeactivatedItemData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2417 + } + }, + { + "name": "ActiveIdValueOnActivation", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataTypeStorage", + "description": { + "kind": "User", + "name": "ImGuiDataTypeStorage" + } + }, + "comments": { + "attached": "// Backup of initial value at the time of activation. ONLY SET BY SPECIFIC WIDGETS: DragXXX and SliderXXX." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2418 + } + }, + { + "name": "LastActiveId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Store the last non-zero ActiveId, useful for animation." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2419 + } + }, + { + "name": "LastActiveIdTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Store the last non-zero ActiveId timer since the beginning of activation, useful for animation." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2420 + } + }, + { + "name": "LastKeyModsChangeTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "comments": { + "preceding": [ + "// Key/Input Ownership + Shortcut Routing system", + "// - The idea is that instead of \"eating\" a given key, we can link to an owner.", + "// - Input query can then read input by specifying ImGuiKeyOwner_Any (== 0), ImGuiKeyOwner_NoOwner (== -1) or a custom ID.", + "// - Routing is requested ahead of time for a given chord (Key + Mods) and granted in NewFrame()." + ], + "attached": "// Record the last time key mods changed (affect repeat delay when using shortcut logic)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2426 + } + }, + { + "name": "LastKeyModsChangeFromNoneTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "comments": { + "attached": "// Record the last time key mods changed away from being 0 (affect repeat delay when using shortcut logic)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2427 + } + }, + { + "name": "LastKeyboardKeyPressTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "comments": { + "attached": "// Record the last time a keyboard key (ignore mouse/gamepad ones) was pressed." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2428 + } + }, + { + "name": "KeysMayBeCharInput", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImBitArrayForNamedKeys", + "description": { + "kind": "User", + "name": "ImBitArrayForNamedKeys" + } + }, + "comments": { + "attached": "// Lookup to tell if a key can emit char input, see IsKeyChordPotentiallyCharInput(). sizeof() = 20 bytes" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2429 + } + }, + { + "name": "KeysOwnerData", + "is_array": true, + "array_bounds": "ImGuiKey_NamedKey_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyOwnerData[ImGuiKey_NamedKey_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiKey_NamedKey_COUNT", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyOwnerData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2430 + } + }, + { + "name": "KeysRoutingTable", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyRoutingTable", + "description": { + "kind": "User", + "name": "ImGuiKeyRoutingTable" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2431 + } + }, + { + "name": "ActiveIdUsingNavDirMask", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// Active widget will want to read those nav move requests (e.g. can activate a button and move away from it)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2432 + } + }, + { + "name": "ActiveIdUsingAllKeyboardKeys", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Active widget will want to read all keyboard keys inputs. (this is a shortcut for not taking ownership of 100+ keys, frequently used by drag operations)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2433 + } + }, + { + "name": "DebugBreakInShortcutRouting", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "attached": "// Set to break in SetShortcutRouting()/Shortcut() calls." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2434 + } + }, + { + "name": "CurrentFocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// Next window/item data" + ], + "attached": "// Value for currently appending items == g.FocusScopeStack.back(). Not to be mistaken with g.NavFocusScopeId." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2438 + } + }, + { + "name": "CurrentItemFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "comments": { + "attached": "// Value for currently appending items == g.ItemFlagsStack.back()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2439 + } + }, + { + "name": "DebugLocateId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Storage for DebugLocateItemOnHover() feature: this is read by ItemAdd() so we keep it in a hot/cached location" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2440 + } + }, + { + "name": "NextItemData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNextItemData", + "description": { + "kind": "User", + "name": "ImGuiNextItemData" + } + }, + "comments": { + "attached": "// Storage for SetNextItem** functions" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2441 + } + }, + { + "name": "LastItemData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiLastItemData", + "description": { + "kind": "User", + "name": "ImGuiLastItemData" + } + }, + "comments": { + "attached": "// Storage for last submitted item (setup by ItemAdd)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2442 + } + }, + { + "name": "NextWindowData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNextWindowData", + "description": { + "kind": "User", + "name": "ImGuiNextWindowData" + } + }, + "comments": { + "attached": "// Storage for SetNextWindow** functions" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2443 + } + }, + { + "name": "DebugShowGroupRects", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2444 + } + }, + { + "name": "DebugFlashStyleColorIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "comments": { + "preceding": [ + "// Shared stacks" + ], + "attached": "// (Keep close to ColorStack to share cache line)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2447 + } + }, + { + "name": "ColorStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiColorMod", + "description": { + "kind": "User", + "name": "ImVector_ImGuiColorMod" + } + }, + "comments": { + "attached": "// Stack for PushStyleColor()/PopStyleColor() - inherited by Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2448 + } + }, + { + "name": "StyleVarStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiStyleMod", + "description": { + "kind": "User", + "name": "ImVector_ImGuiStyleMod" + } + }, + "comments": { + "attached": "// Stack for PushStyleVar()/PopStyleVar() - inherited by Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2449 + } + }, + { + "name": "FontStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontStackData", + "description": { + "kind": "User", + "name": "ImVector_ImFontStackData" + } + }, + "comments": { + "attached": "// Stack for PushFont()/PopFont() - inherited by Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2450 + } + }, + { + "name": "FocusScopeStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiFocusScopeData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiFocusScopeData" + } + }, + "comments": { + "attached": "// Stack for PushFocusScope()/PopFocusScope() - inherited by BeginChild(), pushed into by Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2451 + } + }, + { + "name": "ItemFlagsStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImVector_ImGuiItemFlags" + } + }, + "comments": { + "attached": "// Stack for PushItemFlag()/PopItemFlag() - inherited by Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2452 + } + }, + { + "name": "GroupStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiGroupData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiGroupData" + } + }, + "comments": { + "attached": "// Stack for BeginGroup()/EndGroup() - not inherited by Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2453 + } + }, + { + "name": "OpenPopupStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiPopupData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiPopupData" + } + }, + "comments": { + "attached": "// Which popups are open (persistent)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2454 + } + }, + { + "name": "BeginPopupStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiPopupData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiPopupData" + } + }, + "comments": { + "attached": "// Which level of BeginPopup() we are in (reset every frame)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2455 + } + }, + { + "name": "TreeNodeStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTreeNodeStackData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTreeNodeStackData" + } + }, + "comments": { + "attached": "// Stack for TreeNode()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2456 + } + }, + { + "name": "Viewports", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiViewportPPtr", + "description": { + "kind": "User", + "name": "ImVector_ImGuiViewportPPtr" + } + }, + "comments": { + "preceding": [ + "// Viewports" + ], + "attached": "// Active viewports (always 1+, and generally 1 unless multi-viewports are enabled). Each viewports hold their copy of ImDrawData." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2459 + } + }, + { + "name": "CurrentViewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "comments": { + "attached": "// We track changes of viewport (happening in Begin) so we can call Platform_OnChangedViewport()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2460 + } + }, + { + "name": "MouseViewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2461 + } + }, + { + "name": "MouseLastHoveredViewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "comments": { + "attached": "// Last known viewport that was hovered by mouse (even if we are not hovering any viewport any more) + honoring the _NoInputs flag." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2462 + } + }, + { + "name": "PlatformLastFocusedViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2463 + } + }, + { + "name": "FallbackMonitor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPlatformMonitor", + "description": { + "kind": "User", + "name": "ImGuiPlatformMonitor" + } + }, + "comments": { + "attached": "// Virtual monitor used as fallback if backend doesn't provide monitor information." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2464 + } + }, + { + "name": "PlatformMonitorsFullWorkRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Bounding box of all platform monitors" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2465 + } + }, + { + "name": "ViewportCreatedCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Unique sequential creation counter (mostly for testing/debugging)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2466 + } + }, + { + "name": "PlatformWindowsCreatedCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Unique sequential creation counter (mostly for testing/debugging)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2467 + } + }, + { + "name": "ViewportFocusedStampCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Every time the front-most window changes, we stamp its viewport with an incrementing counter" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2468 + } + }, + { + "name": "NavCursorVisible", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Keyboard/Gamepad Navigation" + ], + "attached": "// Nav focus cursor/rectangle is visible? We hide it after a mouse click. We show it after a nav move." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2471 + } + }, + { + "name": "NavHighlightItemUnderNav", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Disable mouse hovering highlight. Highlight navigation focused item instead of mouse hovered item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2472 + } + }, + { + "name": "NavMousePosDirty", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "//bool NavDisableHighlight; // Old name for !g.NavCursorVisible before 1.91.4 (2024/10/18). OPPOSITE VALUE (g.NavDisableHighlight == !g.NavCursorVisible)", + "//bool NavDisableMouseHover; // Old name for g.NavHighlightItemUnderNav before 1.91.1 (2024/10/18) this was called When user starts using keyboard/gamepad, we hide mouse hovering highlight until mouse is touched again." + ], + "attached": "// When set we will update mouse position if io.ConfigNavMoveSetMousePos is set (not enabled by default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2475 + } + }, + { + "name": "NavIdIsAlive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Nav widget has been seen this frame ~~ NavRectRel is valid" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2476 + } + }, + { + "name": "NavId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Focused item for navigation" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2477 + } + }, + { + "name": "NavWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Focused window for navigation. Could be called 'FocusedWindow'" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2478 + } + }, + { + "name": "NavFocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Focused focus scope (e.g. selection code often wants to \"clear other items\" when landing on an item of the same scope)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2479 + } + }, + { + "name": "NavLayer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavLayer", + "description": { + "kind": "User", + "name": "ImGuiNavLayer" + } + }, + "comments": { + "attached": "// Focused layer (main scrolling layer, or menu/title bar layer)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2480 + } + }, + { + "name": "NavActivateId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ~~ (g.ActiveId == 0) && (IsKeyPressed(ImGuiKey_Space) || IsKeyDown(ImGuiKey_Enter) || IsKeyPressed(ImGuiKey_NavGamepadActivate)) ? NavId : 0, also set when calling ActivateItemByID()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2481 + } + }, + { + "name": "NavActivateDownId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ~~ IsKeyDown(ImGuiKey_Space) || IsKeyDown(ImGuiKey_Enter) || IsKeyDown(ImGuiKey_NavGamepadActivate) ? NavId : 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2482 + } + }, + { + "name": "NavActivatePressedId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ~~ IsKeyPressed(ImGuiKey_Space) || IsKeyPressed(ImGuiKey_Enter) || IsKeyPressed(ImGuiKey_NavGamepadActivate) ? NavId : 0 (no repeat)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2483 + } + }, + { + "name": "NavActivateFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiActivateFlags", + "description": { + "kind": "User", + "name": "ImGuiActivateFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2484 + } + }, + { + "name": "NavFocusRoute", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiFocusScopeData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiFocusScopeData" + } + }, + "comments": { + "attached": "// Reversed copy focus scope stack for NavId (should contains NavFocusScopeId). This essentially follow the window->ParentWindowForFocusRoute chain." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2485 + } + }, + { + "name": "NavHighlightActivatedId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2486 + } + }, + { + "name": "NavHighlightActivatedTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2487 + } + }, + { + "name": "NavNextActivateId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set by ActivateItemByID(), queued until next frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2488 + } + }, + { + "name": "NavNextActivateFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiActivateFlags", + "description": { + "kind": "User", + "name": "ImGuiActivateFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2489 + } + }, + { + "name": "NavInputSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputSource", + "description": { + "kind": "User", + "name": "ImGuiInputSource" + } + }, + "comments": { + "attached": "// Keyboard or Gamepad mode? THIS CAN ONLY BE ImGuiInputSource_Keyboard or ImGuiInputSource_Mouse" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2490 + } + }, + { + "name": "NavLastValidSelectionUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// Last valid data passed to SetNextItemSelectionUser(), or -1. For current window. Not reset when focusing an item that doesn't have selection data." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2491 + } + }, + { + "name": "NavCursorHideFrames", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2492 + } + }, + { + "name": "NavAnyRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Navigation: Init & Move Requests" + ], + "attached": "// ~~ NavMoveRequest || NavInitRequest this is to perform early out in ItemAdd()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2496 + } + }, + { + "name": "NavInitRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Init request for appearing window to select first item" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2497 + } + }, + { + "name": "NavInitRequestFromMove", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2498 + } + }, + { + "name": "NavInitResult", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavItemData", + "description": { + "kind": "User", + "name": "ImGuiNavItemData" + } + }, + "comments": { + "attached": "// Init request result (first item of the window, or one for which SetItemDefaultFocus() was called)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2499 + } + }, + { + "name": "NavMoveSubmitted", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Move request submitted, will process result on next NewFrame()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2500 + } + }, + { + "name": "NavMoveScoringItems", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Move request submitted, still scoring incoming items" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2501 + } + }, + { + "name": "NavMoveForwardToNextFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2502 + } + }, + { + "name": "NavMoveFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavMoveFlags", + "description": { + "kind": "User", + "name": "ImGuiNavMoveFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2503 + } + }, + { + "name": "NavMoveScrollFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiScrollFlags", + "description": { + "kind": "User", + "name": "ImGuiScrollFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2504 + } + }, + { + "name": "NavMoveKeyMods", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2505 + } + }, + { + "name": "NavMoveDir", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "comments": { + "attached": "// Direction of the move request (left/right/up/down)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2506 + } + }, + { + "name": "NavMoveDirForDebug", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2507 + } + }, + { + "name": "NavMoveClipDir", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "comments": { + "attached": "// FIXME-NAV: Describe the purpose of this better. Might want to rename?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2508 + } + }, + { + "name": "NavScoringRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Rectangle used for scoring, in screen space. Based of window->NavRectRel[], modified for directional navigation scoring." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2509 + } + }, + { + "name": "NavScoringNoClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Some nav operations (such as PageUp/PageDown) enforce a region which clipper will attempt to always keep submitted" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2510 + } + }, + { + "name": "NavScoringDebugCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Metrics for debugging" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2511 + } + }, + { + "name": "NavTabbingDir", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Generally -1 or +1, 0 when tabbing without a nav id" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2512 + } + }, + { + "name": "NavTabbingCounter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// >0 when counting items for tabbing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2513 + } + }, + { + "name": "NavMoveResultLocal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavItemData", + "description": { + "kind": "User", + "name": "ImGuiNavItemData" + } + }, + "comments": { + "attached": "// Best move request candidate within NavWindow" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2514 + } + }, + { + "name": "NavMoveResultLocalVisible", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavItemData", + "description": { + "kind": "User", + "name": "ImGuiNavItemData" + } + }, + "comments": { + "attached": "// Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2515 + } + }, + { + "name": "NavMoveResultOther", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavItemData", + "description": { + "kind": "User", + "name": "ImGuiNavItemData" + } + }, + "comments": { + "attached": "// Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2516 + } + }, + { + "name": "NavTabbingResultFirst", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavItemData", + "description": { + "kind": "User", + "name": "ImGuiNavItemData" + } + }, + "comments": { + "attached": "// First tabbing request candidate within NavWindow and flattened hierarchy" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2517 + } + }, + { + "name": "NavJustMovedFromFocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// Navigation: record of last move request" + ], + "attached": "// Just navigated from this focus scope id (result of a successfully MoveRequest)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2520 + } + }, + { + "name": "NavJustMovedToId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Just navigated to this id (result of a successfully MoveRequest)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2521 + } + }, + { + "name": "NavJustMovedToFocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Just navigated to this focus scope id (result of a successfully MoveRequest)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2522 + } + }, + { + "name": "NavJustMovedToKeyMods", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2523 + } + }, + { + "name": "NavJustMovedToIsTabbing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Copy of ImGuiNavMoveFlags_IsTabbing. Maybe we should store whole flags." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2524 + } + }, + { + "name": "NavJustMovedToHasSelectionData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Copy of move result's ItemFlags & ImGuiItemFlags_HasSelectionUserData). Maybe we should just store ImGuiNavItemData." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2525 + } + }, + { + "name": "ConfigNavWindowingWithGamepad", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Navigation: Windowing (CTRL+TAB for list, or Menu button + keys or directional pads to move/resize)" + ], + "attached": "// = true. Enable CTRL+TAB by holding ImGuiKey_GamepadFaceLeft (== ImGuiKey_NavGamepadMenu). When false, the button may still be used to toggle Menu layer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2528 + } + }, + { + "name": "ConfigNavWindowingKeyNext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "attached": "// = ImGuiMod_Ctrl | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiKey_Tab on OS X). For reconfiguration (see #4828)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2529 + } + }, + { + "name": "ConfigNavWindowingKeyPrev", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "attached": "// = ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiMod_Shift | ImGuiKey_Tab on OS X)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2530 + } + }, + { + "name": "NavWindowingTarget", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Target window when doing CTRL+Tab (or Pad Menu + FocusPrev/Next), this window is temporarily displayed top-most!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2531 + } + }, + { + "name": "NavWindowingTargetAnim", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f, so the fade-out can stay on it." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2532 + } + }, + { + "name": "NavWindowingListWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Internal window actually listing the CTRL+Tab contents" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2533 + } + }, + { + "name": "NavWindowingTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2534 + } + }, + { + "name": "NavWindowingHighlightAlpha", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2535 + } + }, + { + "name": "NavWindowingInputSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputSource", + "description": { + "kind": "User", + "name": "ImGuiInputSource" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2536 + } + }, + { + "name": "NavWindowingToggleLayer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set while Alt or GamepadMenu is held, may be cleared by other operations, and processed when releasing the key." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2537 + } + }, + { + "name": "NavWindowingToggleKey", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "comments": { + "attached": "// Keyboard/gamepad key used when toggling to menu layer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2538 + } + }, + { + "name": "NavWindowingAccumDeltaPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2539 + } + }, + { + "name": "NavWindowingAccumDeltaSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2540 + } + }, + { + "name": "DimBgRatio", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// Render" + ], + "attached": "// 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2543 + } + }, + { + "name": "DragDropActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Drag and Drop" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2546 + } + }, + { + "name": "DragDropWithinSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag source." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2547 + } + }, + { + "name": "DragDropWithinTarget", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag target." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2548 + } + }, + { + "name": "DragDropSourceFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDragDropFlags", + "description": { + "kind": "User", + "name": "ImGuiDragDropFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2549 + } + }, + { + "name": "DragDropSourceFrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2550 + } + }, + { + "name": "DragDropMouseButton", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2551 + } + }, + { + "name": "DragDropPayload", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPayload", + "description": { + "kind": "User", + "name": "ImGuiPayload" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2552 + } + }, + { + "name": "DragDropTargetRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Store rectangle of current target candidate (we favor small targets when overlapping)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2553 + } + }, + { + "name": "DragDropTargetClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Store ClipRect at the time of item's drawing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2554 + } + }, + { + "name": "DragDropTargetId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2555 + } + }, + { + "name": "DragDropAcceptFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDragDropFlags", + "description": { + "kind": "User", + "name": "ImGuiDragDropFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2556 + } + }, + { + "name": "DragDropAcceptIdCurrRectSurface", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Target item surface (we resolve overlapping targets by prioritizing the smaller surface)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2557 + } + }, + { + "name": "DragDropAcceptIdCurr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Target item id (set at the time of accepting the payload)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2558 + } + }, + { + "name": "DragDropAcceptIdPrev", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2559 + } + }, + { + "name": "DragDropAcceptFrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last time a target expressed a desire to accept the source" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2560 + } + }, + { + "name": "DragDropHoldJustPressedId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set when holding a payload just made ButtonBehavior() return a press." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2561 + } + }, + { + "name": "DragDropPayloadBufHeap", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_unsigned_char", + "description": { + "kind": "User", + "name": "ImVector_unsigned_char" + } + }, + "comments": { + "attached": "// We don't expose the ImVector<> directly, ImGuiPayload only holds pointer+size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2562 + } + }, + { + "name": "DragDropPayloadBufLocal", + "is_array": true, + "array_bounds": "16", + "is_anonymous": false, + "type": { + "declaration": "unsigned char[16]", + "description": { + "kind": "Array", + "bounds": "16", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char" + } + } + }, + "comments": { + "attached": "// Local buffer for small payloads" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2563 + } + }, + { + "name": "ClipperTempDataStacked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Clipper" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2566 + } + }, + { + "name": "ClipperTempData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiListClipperData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiListClipperData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2567 + } + }, + { + "name": "CurrentTable", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "comments": { + "preceding": [ + "// Tables" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2570 + } + }, + { + "name": "DebugBreakInTable", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set to break in BeginTable() call." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2571 + } + }, + { + "name": "TablesTempDataStacked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Temporary table data size (because we leave previous instances undestructed, we generally don't use TablesTempData.Size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2572 + } + }, + { + "name": "TablesTempData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTableTempData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTableTempData" + } + }, + "comments": { + "attached": "// Temporary table data (buffers reused/shared across instances, support nesting)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2573 + } + }, + { + "name": "Tables", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPool_ImGuiTable", + "description": { + "kind": "User", + "name": "ImPool_ImGuiTable" + } + }, + "comments": { + "attached": "// Persistent table data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2574 + } + }, + { + "name": "TablesLastTimeActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_float", + "description": { + "kind": "User", + "name": "ImVector_float" + } + }, + "comments": { + "attached": "// Last used timestamp of each tables (SOA, for efficient GC)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2575 + } + }, + { + "name": "DrawChannelsTempMergeBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawChannel", + "description": { + "kind": "User", + "name": "ImVector_ImDrawChannel" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2576 + } + }, + { + "name": "CurrentTabBar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "comments": { + "preceding": [ + "// Tab bars" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2579 + } + }, + { + "name": "TabBars", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPool_ImGuiTabBar", + "description": { + "kind": "User", + "name": "ImPool_ImGuiTabBar" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2580 + } + }, + { + "name": "CurrentTabBarStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiPtrOrIndex", + "description": { + "kind": "User", + "name": "ImVector_ImGuiPtrOrIndex" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2581 + } + }, + { + "name": "ShrinkWidthBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiShrinkWidthItem", + "description": { + "kind": "User", + "name": "ImVector_ImGuiShrinkWidthItem" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2582 + } + }, + { + "name": "BoxSelectState", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiBoxSelectState", + "description": { + "kind": "User", + "name": "ImGuiBoxSelectState" + } + }, + "comments": { + "preceding": [ + "// Multi-Select state" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2585 + } + }, + { + "name": "CurrentMultiSelect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMultiSelectTempData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectTempData" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2586 + } + }, + { + "name": "MultiSelectTempDataStacked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Temporary multi-select data size (because we leave previous instances undestructed, we generally don't use MultiSelectTempData.Size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2587 + } + }, + { + "name": "MultiSelectTempData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiMultiSelectTempData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiMultiSelectTempData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2588 + } + }, + { + "name": "MultiSelectStorage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImPool_ImGuiMultiSelectState", + "description": { + "kind": "User", + "name": "ImPool_ImGuiMultiSelectState" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2589 + } + }, + { + "name": "HoverItemDelayId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// Hover Delay system" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2592 + } + }, + { + "name": "HoverItemDelayIdPreviousFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2593 + } + }, + { + "name": "HoverItemDelayTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Currently used by IsItemHovered()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2594 + } + }, + { + "name": "HoverItemDelayClearTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Currently used by IsItemHovered(): grace time before g.TooltipHoverTimer gets cleared." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2595 + } + }, + { + "name": "HoverItemUnlockedStationaryId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Mouse has once been stationary on this item. Only reset after departing the item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2596 + } + }, + { + "name": "HoverWindowUnlockedStationaryId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Mouse has once been stationary on this window. Only reset after departing the window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2597 + } + }, + { + "name": "MouseCursor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMouseCursor", + "description": { + "kind": "User", + "name": "ImGuiMouseCursor" + } + }, + "comments": { + "preceding": [ + "// Mouse state" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2600 + } + }, + { + "name": "MouseStationaryTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Time the mouse has been stationary (with some loose heuristic)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2601 + } + }, + { + "name": "MouseLastValidPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2602 + } + }, + { + "name": "InputTextState", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputTextState", + "description": { + "kind": "User", + "name": "ImGuiInputTextState" + } + }, + "comments": { + "preceding": [ + "// Widget state" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2605 + } + }, + { + "name": "InputTextDeactivatedState", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputTextDeactivatedState", + "description": { + "kind": "User", + "name": "ImGuiInputTextDeactivatedState" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2606 + } + }, + { + "name": "InputTextPasswordFontBackupBaked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontBaked", + "description": { + "kind": "User", + "name": "ImFontBaked" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2607 + } + }, + { + "name": "InputTextPasswordFontBackupFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontFlags", + "description": { + "kind": "User", + "name": "ImFontFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2608 + } + }, + { + "name": "TempInputId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Temporary text input when CTRL+clicking on a slider, etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2609 + } + }, + { + "name": "DataTypeZeroValue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDataTypeStorage", + "description": { + "kind": "User", + "name": "ImGuiDataTypeStorage" + } + }, + "comments": { + "attached": "// 0 for all data types" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2610 + } + }, + { + "name": "BeginMenuDepth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2611 + } + }, + { + "name": "BeginComboDepth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2612 + } + }, + { + "name": "ColorEditOptions", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "comments": { + "attached": "// Store user options for color edit widgets" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2613 + } + }, + { + "name": "ColorEditCurrentID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set temporarily while inside of the parent-most ColorEdit4/ColorPicker4 (because they call each others)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2614 + } + }, + { + "name": "ColorEditSavedID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID we are saving/restoring HS for" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2615 + } + }, + { + "name": "ColorEditSavedHue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Backup of last Hue associated to LastColor, so we can restore Hue in lossy RGB<>HSV round trips" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2616 + } + }, + { + "name": "ColorEditSavedSat", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Backup of last Saturation associated to LastColor, so we can restore Saturation in lossy RGB<>HSV round trips" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2617 + } + }, + { + "name": "ColorEditSavedColor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// RGB value with alpha set to 0." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2618 + } + }, + { + "name": "ColorPickerRef", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "comments": { + "attached": "// Initial/reference color at the time of opening the color picker." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2619 + } + }, + { + "name": "ComboPreviewData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiComboPreviewData", + "description": { + "kind": "User", + "name": "ImGuiComboPreviewData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2620 + } + }, + { + "name": "WindowResizeBorderExpectedRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Expected border rect, switch to relative edit if moving" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2621 + } + }, + { + "name": "WindowResizeRelativeMode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2622 + } + }, + { + "name": "ScrollbarSeekMode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// 0: scroll to clicked location, -1/+1: prev/next page." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2623 + } + }, + { + "name": "ScrollbarClickDeltaToGrabCenter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// When scrolling to mouse location: distance between mouse and center of grab box, normalized in parent space." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2624 + } + }, + { + "name": "SliderGrabClickOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2625 + } + }, + { + "name": "SliderCurrentAccum", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Accumulated slider delta when using navigation controls." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2626 + } + }, + { + "name": "SliderCurrentAccumDirty", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Has the accumulated slider delta changed since last time we tried to apply it?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2627 + } + }, + { + "name": "DragCurrentAccumDirty", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2628 + } + }, + { + "name": "DragCurrentAccum", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2629 + } + }, + { + "name": "DragSpeedDefaultRatio", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2630 + } + }, + { + "name": "DisabledAlphaBackup", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Backup for style.Alpha for BeginDisabled()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2631 + } + }, + { + "name": "DisabledStackSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2632 + } + }, + { + "name": "TooltipOverrideCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2633 + } + }, + { + "name": "TooltipPreviousWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Window of last tooltip submitted during the frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2634 + } + }, + { + "name": "ClipboardHandlerData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "comments": { + "attached": "// If no custom clipboard handler is defined" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2635 + } + }, + { + "name": "MenusIdSubmittedThisFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiID", + "description": { + "kind": "User", + "name": "ImVector_ImGuiID" + } + }, + "comments": { + "attached": "// A list of menu IDs that were rendered at least once" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2636 + } + }, + { + "name": "TypingSelectState", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTypingSelectState", + "description": { + "kind": "User", + "name": "ImGuiTypingSelectState" + } + }, + "comments": { + "attached": "// State for GetTypingSelectRequest()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2637 + } + }, + { + "name": "PlatformImeData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPlatformImeData", + "description": { + "kind": "User", + "name": "ImGuiPlatformImeData" + } + }, + "comments": { + "preceding": [ + "// Platform support" + ], + "attached": "// Data updated by current frame. Will be applied at end of the frame. For some backends, this is required to have WantVisible=true in order to receive text message." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2640 + } + }, + { + "name": "PlatformImeDataPrev", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPlatformImeData", + "description": { + "kind": "User", + "name": "ImGuiPlatformImeData" + } + }, + "comments": { + "attached": "// Previous frame data. When changed we call the platform_io.Platform_SetImeDataFn() handler." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2641 + } + }, + { + "name": "UserTextures", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImTextureDataPtr", + "description": { + "kind": "User", + "name": "ImVector_ImTextureDataPtr" + } + }, + "comments": { + "preceding": [ + "// Extensions", + "// FIXME: We could provide an API to register one slot in an array held in ImGuiContext?" + ], + "attached": "// List of textures created/managed by user or third-party extension. Automatically appended into platform_io.Textures[]." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2645 + } + }, + { + "name": "DockContext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockContext", + "description": { + "kind": "User", + "name": "ImGuiDockContext" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2646 + } + }, + { + "name": "DockNodeWindowMenuHandler", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*DockNodeWindowMenuHandler)(ImGuiContext* ctx, ImGuiDockNode* node, ImGuiTabBar* tab_bar)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "DockNodeWindowMenuHandler", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "node", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + { + "kind": "Type", + "name": "tab_bar", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "SettingsLoaded", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Settings" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2650 + } + }, + { + "name": "SettingsDirtyTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Save .ini Settings to memory when time reaches zero" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2651 + } + }, + { + "name": "SettingsIniData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextBuffer", + "description": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + }, + "comments": { + "attached": "// In memory .ini settings" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2652 + } + }, + { + "name": "SettingsHandlers", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiSettingsHandler", + "description": { + "kind": "User", + "name": "ImVector_ImGuiSettingsHandler" + } + }, + "comments": { + "attached": "// List of .ini settings handlers" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2653 + } + }, + { + "name": "SettingsWindows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImChunkStream_ImGuiWindowSettings", + "description": { + "kind": "User", + "name": "ImChunkStream_ImGuiWindowSettings" + } + }, + "comments": { + "attached": "// ImGuiWindow .ini settings entries" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2654 + } + }, + { + "name": "SettingsTables", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImChunkStream_ImGuiTableSettings", + "description": { + "kind": "User", + "name": "ImChunkStream_ImGuiTableSettings" + } + }, + "comments": { + "attached": "// ImGuiTable .ini settings entries" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2655 + } + }, + { + "name": "Hooks", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiContextHook", + "description": { + "kind": "User", + "name": "ImVector_ImGuiContextHook" + } + }, + "comments": { + "attached": "// Hooks for extensions (e.g. test engine)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2656 + } + }, + { + "name": "HookIdNext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Next available HookId" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2657 + } + }, + { + "name": "LocalizationTable", + "is_array": true, + "array_bounds": "ImGuiLocKey_COUNT", + "is_anonymous": false, + "type": { + "declaration": "const char*[ImGuiLocKey_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiLocKey_COUNT", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Localization" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2660 + } + }, + { + "name": "LogEnabled", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Capture/Logging" + ], + "attached": "// Currently capturing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2663 + } + }, + { + "name": "LogFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiLogFlags", + "description": { + "kind": "User", + "name": "ImGuiLogFlags" + } + }, + "comments": { + "attached": "// Capture flags/type" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2664 + } + }, + { + "name": "LogWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2665 + } + }, + { + "name": "LogFile", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "comments": { + "attached": "// If != NULL log to stdout/ file" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2666 + } + }, + { + "name": "LogBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextBuffer", + "description": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + }, + "comments": { + "attached": "// Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2667 + } + }, + { + "name": "LogNextPrefix", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2668 + } + }, + { + "name": "LogNextSuffix", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2669 + } + }, + { + "name": "LogLinePosY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2670 + } + }, + { + "name": "LogLineFirstItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2671 + } + }, + { + "name": "LogDepthRef", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2672 + } + }, + { + "name": "LogDepthToExpand", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2673 + } + }, + { + "name": "LogDepthToExpandDefault", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Default/stored value for LogDepthMaxExpand if not specified in the LogXXX function call." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2674 + } + }, + { + "name": "ErrorCallback", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiErrorCallback", + "description": { + "kind": "User", + "name": "ImGuiErrorCallback" + } + }, + "comments": { + "preceding": [ + "// Error Handling" + ], + "attached": "// = NULL. May be exposed in public API eventually." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2677 + } + }, + { + "name": "ErrorCallbackUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2678 + } + }, + { + "name": "ErrorTooltipLockedPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2679 + } + }, + { + "name": "ErrorFirst", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2680 + } + }, + { + "name": "ErrorCountCurrentFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// [Internal] Number of errors submitted this frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2681 + } + }, + { + "name": "StackSizesInNewFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiErrorRecoveryState", + "description": { + "kind": "User", + "name": "ImGuiErrorRecoveryState" + } + }, + "comments": { + "attached": "// [Internal]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2682 + } + }, + { + "name": "StackSizesInBeginForCurrentWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiErrorRecoveryState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiErrorRecoveryState" + } + } + }, + "comments": { + "attached": "// [Internal]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2683 + } + }, + { + "name": "DebugDrawIdConflictsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Debug Tools", + "// (some of the highly frequently used data are interleaved in other structures above: DebugBreakXXX fields, DebugHookIdInfo, DebugLocateId etc.)" + ], + "attached": "// Locked count (preserved when holding CTRL)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2687 + } + }, + { + "name": "DebugLogFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDebugLogFlags", + "description": { + "kind": "User", + "name": "ImGuiDebugLogFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2688 + } + }, + { + "name": "DebugLogBuf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextBuffer", + "description": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2689 + } + }, + { + "name": "DebugLogIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextIndex", + "description": { + "kind": "User", + "name": "ImGuiTextIndex" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2690 + } + }, + { + "name": "DebugLogSkippedErrors", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2691 + } + }, + { + "name": "DebugLogAutoDisableFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDebugLogFlags", + "description": { + "kind": "User", + "name": "ImGuiDebugLogFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2692 + } + }, + { + "name": "DebugLogAutoDisableFrames", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2693 + } + }, + { + "name": "DebugLocateFrames", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// For DebugLocateItemOnHover(). This is used together with DebugLocateId which is in a hot/cached spot above." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2694 + } + }, + { + "name": "DebugBreakInLocateId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Debug break in ItemAdd() call for g.DebugLocateId." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2695 + } + }, + { + "name": "DebugBreakKeyChord", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "attached": "// = ImGuiKey_Pause" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2696 + } + }, + { + "name": "DebugBeginReturnValueCullDepth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Cycle between 0..9 then wrap around." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2697 + } + }, + { + "name": "DebugItemPickerActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Item picker is active (started with DebugStartItemPicker())" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2698 + } + }, + { + "name": "DebugItemPickerMouseButton", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2699 + } + }, + { + "name": "DebugItemPickerBreakId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Will call IM_DEBUG_BREAK() when encountering this ID" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2700 + } + }, + { + "name": "DebugFlashStyleColorTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2701 + } + }, + { + "name": "DebugFlashStyleColorBackup", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2702 + } + }, + { + "name": "DebugMetricsConfig", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMetricsConfig", + "description": { + "kind": "User", + "name": "ImGuiMetricsConfig" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2703 + } + }, + { + "name": "DebugIDStackTool", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiIDStackTool", + "description": { + "kind": "User", + "name": "ImGuiIDStackTool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2704 + } + }, + { + "name": "DebugAllocInfo", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDebugAllocInfo", + "description": { + "kind": "User", + "name": "ImGuiDebugAllocInfo" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2705 + } + }, + { + "name": "DebugHoveredDockNode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "comments": { + "attached": "// Hovered dock node." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2706 + } + }, + { + "name": "DebugDrawIdConflictsAliveCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "conditionals": [ + { + "condition": "if", + "expression": "defined(IMGUI_DEBUG_HIGHLIGHT_ALL_ID_CONFLICTS)&&!defined(IMGUI_DISABLE_DEBUG_TOOLS)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2708 + } + }, + { + "name": "DebugDrawIdConflictsHighlightSet", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "conditionals": [ + { + "condition": "if", + "expression": "defined(IMGUI_DEBUG_HIGHLIGHT_ALL_ID_CONFLICTS)&&!defined(IMGUI_DISABLE_DEBUG_TOOLS)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2709 + } + }, + { + "name": "FramerateSecPerFrame", + "is_array": true, + "array_bounds": "60", + "is_anonymous": false, + "type": { + "declaration": "float[60]", + "description": { + "kind": "Array", + "bounds": "60", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "comments": { + "preceding": [ + "// Misc" + ], + "attached": "// Calculate estimate of framerate for user over the last 60 frames.." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2713 + } + }, + { + "name": "FramerateSecPerFrameIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2714 + } + }, + { + "name": "FramerateSecPerFrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2715 + } + }, + { + "name": "FramerateSecPerFrameAccum", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2716 + } + }, + { + "name": "WantCaptureMouseNextFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Explicit capture override via SetNextFrameWantCaptureMouse()/SetNextFrameWantCaptureKeyboard(). Default to -1." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2717 + } + }, + { + "name": "WantCaptureKeyboardNextFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2718 + } + }, + { + "name": "WantTextInputNextFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Copied in EndFrame() from g.PlatformImeData.WantTextInput. Needs to be set for some backends (SDL3) to emit character inputs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2719 + } + }, + { + "name": "TempBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "comments": { + "attached": "// Temporary text buffer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2720 + } + }, + { + "name": "TempKeychordName", + "is_array": true, + "array_bounds": "64", + "is_anonymous": false, + "type": { + "declaration": "char[64]", + "description": { + "kind": "Array", + "bounds": "64", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2721 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2332 + } + }, + { + "name": "ImGuiWindowTempData", + "original_fully_qualified_name": "ImGuiWindowTempData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "CursorPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "preceding": [ + "// Layout" + ], + "attached": "// Current emitting position, in absolute coordinates." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2736 + } + }, + { + "name": "CursorPosPrevLine", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2737 + } + }, + { + "name": "CursorStartPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Initial position after Begin(), generally ~ window position + WindowPadding." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2738 + } + }, + { + "name": "CursorMaxPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Used to implicitly calculate ContentSize at the beginning of next frame, for scrolling range and auto-resize. Always growing during the frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2739 + } + }, + { + "name": "IdealMaxPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Used to implicitly calculate ContentSizeIdeal at the beginning of next frame, for auto-resize only. Always growing during the frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2740 + } + }, + { + "name": "CurrLineSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2741 + } + }, + { + "name": "PrevLineSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2742 + } + }, + { + "name": "CurrLineTextBaseOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Baseline offset (0.0f by default on a new line, generally == style.FramePadding.y when a framed item has been added)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2743 + } + }, + { + "name": "PrevLineTextBaseOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2744 + } + }, + { + "name": "IsSameLine", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2745 + } + }, + { + "name": "IsSetPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2746 + } + }, + { + "name": "Indent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec1", + "description": { + "kind": "User", + "name": "ImVec1" + } + }, + "comments": { + "attached": "// Indentation / start position from left of window (increased by TreePush/TreePop, etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2747 + } + }, + { + "name": "ColumnsOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec1", + "description": { + "kind": "User", + "name": "ImVec1" + } + }, + "comments": { + "attached": "// Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2748 + } + }, + { + "name": "GroupOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec1", + "description": { + "kind": "User", + "name": "ImVec1" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2749 + } + }, + { + "name": "CursorStartPosLossyness", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Record the loss of precision of CursorStartPos due to really large scrolling amount. This is used by clipper to compensate and fix the most common use case of large scroll area." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2750 + } + }, + { + "name": "NavLayerCurrent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiNavLayer", + "description": { + "kind": "User", + "name": "ImGuiNavLayer" + } + }, + "comments": { + "preceding": [ + "// Keyboard/Gamepad navigation" + ], + "attached": "// Current layer, 0..31 (we currently only use 0..1)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2753 + } + }, + { + "name": "NavLayersActiveMask", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Which layers have been written to (result from previous frame)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2754 + } + }, + { + "name": "NavLayersActiveMaskNext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Which layers have been written to (accumulator for current frame)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2755 + } + }, + { + "name": "NavIsScrollPushableX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when current work location may be scrolled horizontally when moving left / right. This is generally always true UNLESS within a column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2756 + } + }, + { + "name": "NavHideHighlightOneFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2757 + } + }, + { + "name": "NavWindowHasScrollY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set per window when scrolling can be used (== ScrollMax.y > 0.0f)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2758 + } + }, + { + "name": "MenuBarAppending", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Miscellaneous" + ], + "attached": "// FIXME: Remove this" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2761 + } + }, + { + "name": "MenuBarOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// MenuBarOffset.x is sort of equivalent of a per-layer CursorPos.x, saved/restored as we switch to the menu bar. The only situation when MenuBarOffset.y is > 0 if when (SafeAreaPadding.y > FramePadding.y), often used on TVs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2762 + } + }, + { + "name": "MenuColumns", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMenuColumns", + "description": { + "kind": "User", + "name": "ImGuiMenuColumns" + } + }, + "comments": { + "attached": "// Simplified columns storage for menu items measurement" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2763 + } + }, + { + "name": "TreeDepth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Current tree depth." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2764 + } + }, + { + "name": "TreeHasStackDataDepthMask", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// Store whether given depth has ImGuiTreeNodeStackData data. Could be turned into a ImU64 if necessary." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2765 + } + }, + { + "name": "TreeRecordsClippedNodesY2Mask", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// Store whether we should keep recording Y2. Cleared when passing clip max. Equivalent TreeHasStackDataDepthMask value should always be set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2766 + } + }, + { + "name": "ChildWindows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiWindowPtr", + "description": { + "kind": "User", + "name": "ImVector_ImGuiWindowPtr" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2767 + } + }, + { + "name": "StateStorage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "comments": { + "attached": "// Current persistent per-window storage (store e.g. tree node open/close state)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2768 + } + }, + { + "name": "CurrentColumns", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiOldColumns*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiOldColumns" + } + } + }, + "comments": { + "attached": "// Current columns set" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2769 + } + }, + { + "name": "CurrentTableIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Current table index (into g.Tables)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2770 + } + }, + { + "name": "LayoutType", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiLayoutType", + "description": { + "kind": "User", + "name": "ImGuiLayoutType" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2771 + } + }, + { + "name": "ParentLayoutType", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiLayoutType", + "description": { + "kind": "User", + "name": "ImGuiLayoutType" + } + }, + "comments": { + "attached": "// Layout type of parent window at the time of Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2772 + } + }, + { + "name": "ModalDimBgColor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2773 + } + }, + { + "name": "WindowItemStatusFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemStatusFlags", + "description": { + "kind": "User", + "name": "ImGuiItemStatusFlags" + } + }, + "comments": { + "preceding": [ + "// Status flags" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2776 + } + }, + { + "name": "ChildItemStatusFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemStatusFlags", + "description": { + "kind": "User", + "name": "ImGuiItemStatusFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2777 + } + }, + { + "name": "DockTabItemStatusFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiItemStatusFlags", + "description": { + "kind": "User", + "name": "ImGuiItemStatusFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2778 + } + }, + { + "name": "DockTabItemRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2779 + } + }, + { + "name": "ItemWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// Local parameters stacks", + "// We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings." + ], + "attached": "// Current item width (>0.0: width in pixels, <0.0: align xx pixels to the right of window)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2783 + } + }, + { + "name": "TextWrapPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Current text wrap pos." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2784 + } + }, + { + "name": "ItemWidthStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_float", + "description": { + "kind": "User", + "name": "ImVector_float" + } + }, + "comments": { + "attached": "// Store item widths to restore (attention: .back() is not == ItemWidth)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2785 + } + }, + { + "name": "TextWrapPosStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_float", + "description": { + "kind": "User", + "name": "ImVector_float" + } + }, + "comments": { + "attached": "// Store text wrap pos to restore (attention: .back() is not == TextWrapPos)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2786 + } + } + ], + "comments": { + "preceding": [ + "// Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow.", + "// (That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered..)", + "// (This doesn't need a constructor because we zero-clear it as part of ImGuiWindow and all frame-temporary data are setup on Begin)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2733 + } + }, + { + "name": "ImGuiWindow", + "original_fully_qualified_name": "ImGuiWindow", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Ctx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "comments": { + "attached": "// Parent UI context (needs to be set explicitly by parent)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2792 + } + }, + { + "name": "Name", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "comments": { + "attached": "// Window name, owned by the window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2793 + } + }, + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// == ImHashStr(Name)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2794 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "comments": { + "attached": "// See enum ImGuiWindowFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2795 + } + }, + { + "name": "FlagsPreviousFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "comments": { + "attached": "// See enum ImGuiWindowFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2795 + } + }, + { + "name": "ChildFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiChildFlags", + "description": { + "kind": "User", + "name": "ImGuiChildFlags" + } + }, + "comments": { + "attached": "// Set when window is a child window. See enum ImGuiChildFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2796 + } + }, + { + "name": "WindowClass", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowClass", + "description": { + "kind": "User", + "name": "ImGuiWindowClass" + } + }, + "comments": { + "attached": "// Advanced users only. Set with SetNextWindowClass()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2797 + } + }, + { + "name": "Viewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "comments": { + "attached": "// Always set in Begin(). Inactive windows may have a NULL value here if their viewport was discarded." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2798 + } + }, + { + "name": "ViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// We backup the viewport id (since the viewport may disappear or never be created if the window is inactive)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2799 + } + }, + { + "name": "ViewportPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// We backup the viewport position (since the viewport may disappear or never be created if the window is inactive)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2800 + } + }, + { + "name": "ViewportAllowPlatformMonitorExtend", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Reset to -1 every frame (index is guaranteed to be valid between NewFrame..EndFrame), only used in the Appearing frame of a tooltip/popup to enforce clamping to a given monitor" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2801 + } + }, + { + "name": "Pos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Position (always rounded-up to nearest pixel)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2802 + } + }, + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Current size (==SizeFull or collapsed title bar size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2803 + } + }, + { + "name": "SizeFull", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Size when non collapsed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2804 + } + }, + { + "name": "ContentSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Size of contents/scrollable client area (calculated from the extents reach of the cursor) from previous frame. Does not include window decoration or window padding." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2805 + } + }, + { + "name": "ContentSizeIdeal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2806 + } + }, + { + "name": "ContentSizeExplicit", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Size of contents/scrollable client area explicitly request by the user via SetNextWindowContentSize()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2807 + } + }, + { + "name": "WindowPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Window padding at the time of Begin()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2808 + } + }, + { + "name": "WindowRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Window rounding at the time of Begin(). May be clamped lower to avoid rendering artifacts with title bar, menu bar etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2809 + } + }, + { + "name": "WindowBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Window border size at the time of Begin()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2810 + } + }, + { + "name": "TitleBarHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Note that those used to be function before 2024/05/28. If you have old code calling TitleBarHeight() you can change it to TitleBarHeight." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2811 + } + }, + { + "name": "MenuBarHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Note that those used to be function before 2024/05/28. If you have old code calling TitleBarHeight() you can change it to TitleBarHeight." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2811 + } + }, + { + "name": "DecoOuterSizeX1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Left/Up offsets. Sum of non-scrolling outer decorations (X1 generally == 0.0f. Y1 generally = TitleBarHeight + MenuBarHeight). Locked during Begin()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2812 + } + }, + { + "name": "DecoOuterSizeY1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Left/Up offsets. Sum of non-scrolling outer decorations (X1 generally == 0.0f. Y1 generally = TitleBarHeight + MenuBarHeight). Locked during Begin()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2812 + } + }, + { + "name": "DecoOuterSizeX2", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Right/Down offsets (X2 generally == ScrollbarSize.x, Y2 == ScrollbarSizes.y)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2813 + } + }, + { + "name": "DecoOuterSizeY2", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Right/Down offsets (X2 generally == ScrollbarSize.x, Y2 == ScrollbarSizes.y)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2813 + } + }, + { + "name": "DecoInnerSizeX1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Applied AFTER/OVER InnerRect. Specialized for Tables as they use specialized form of clipping and frozen rows/columns are inside InnerRect (and not part of regular decoration sizes)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2814 + } + }, + { + "name": "DecoInnerSizeY1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Applied AFTER/OVER InnerRect. Specialized for Tables as they use specialized form of clipping and frozen rows/columns are inside InnerRect (and not part of regular decoration sizes)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2814 + } + }, + { + "name": "NameBufLen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Size of buffer storing Name. May be larger than strlen(Name)!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2815 + } + }, + { + "name": "MoveId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// == window->GetID(\"#MOVE\")" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2816 + } + }, + { + "name": "TabId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// == window->GetID(\"#TAB\")" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2817 + } + }, + { + "name": "ChildId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID of corresponding item in parent window (for navigation to return from child window to parent window)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2818 + } + }, + { + "name": "PopupId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2819 + } + }, + { + "name": "Scroll", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2820 + } + }, + { + "name": "ScrollMax", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2821 + } + }, + { + "name": "ScrollTarget", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2822 + } + }, + { + "name": "ScrollTargetCenterRatio", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2823 + } + }, + { + "name": "ScrollTargetEdgeSnapDist", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// 0.0f = no snapping, >0.0f snapping threshold" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2824 + } + }, + { + "name": "ScrollbarSizes", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Size taken by each scrollbars on their smaller axis. Pay attention! ScrollbarSizes.x == width of the vertical scrollbar, ScrollbarSizes.y = height of the horizontal scrollbar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2825 + } + }, + { + "name": "ScrollbarX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Are scrollbars visible?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2826 + } + }, + { + "name": "ScrollbarY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Are scrollbars visible?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2826 + } + }, + { + "name": "ScrollbarXStabilizeEnabled", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Was ScrollbarX previously auto-stabilized?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2827 + } + }, + { + "name": "ScrollbarXStabilizeToggledHistory", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Used to stabilize scrollbar visibility in case of feedback loops" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2828 + } + }, + { + "name": "ViewportOwned", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2829 + } + }, + { + "name": "Active", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to true on Begin(), unless Collapsed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2830 + } + }, + { + "name": "WasActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2831 + } + }, + { + "name": "WriteAccessed", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to true when any widget access the current window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2832 + } + }, + { + "name": "Collapsed", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when collapsing window to become only title-bar" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2833 + } + }, + { + "name": "WantCollapseToggle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2834 + } + }, + { + "name": "SkipItems", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when items can safely be all clipped (e.g. window not visible or collapsed)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2835 + } + }, + { + "name": "SkipRefresh", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// [EXPERIMENTAL] Reuse previous frame drawn contents, Begin() returns false." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2836 + } + }, + { + "name": "Appearing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set during the frame where the window is appearing (or re-appearing)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2837 + } + }, + { + "name": "Hidden", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Do not display (== HiddenFrames*** > 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2838 + } + }, + { + "name": "IsFallbackWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set on the \"Debug##Default\" window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2839 + } + }, + { + "name": "IsExplicitChild", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when passed _ChildWindow, left to false by BeginDocked()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2840 + } + }, + { + "name": "HasCloseButton", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when the window has a close button (p_open != NULL)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2841 + } + }, + { + "name": "ResizeBorderHovered", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "signed char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "comments": { + "attached": "// Current border being hovered for resize (-1: none, otherwise 0-3)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2842 + } + }, + { + "name": "ResizeBorderHeld", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "signed char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "comments": { + "attached": "// Current border being held for resize (-1: none, otherwise 0-3)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2843 + } + }, + { + "name": "BeginCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2844 + } + }, + { + "name": "BeginCountPreviousFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Number of Begin() during the previous frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2845 + } + }, + { + "name": "BeginOrderWithinParent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Begin() order within immediate parent window, if we are a child window. Otherwise 0." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2846 + } + }, + { + "name": "BeginOrderWithinContext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Begin() order within entire imgui context. This is mostly used for debugging submission order related issues." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2847 + } + }, + { + "name": "FocusOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Order within WindowsFocusOrder[], altered when windows are focused." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2848 + } + }, + { + "name": "AutoFitFramesX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2849 + } + }, + { + "name": "AutoFitFramesY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2849 + } + }, + { + "name": "AutoFitOnlyGrows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2850 + } + }, + { + "name": "AutoPosLastDirection", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2851 + } + }, + { + "name": "HiddenFramesCanSkipItems", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Hide the window for N frames" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2852 + } + }, + { + "name": "HiddenFramesCannotSkipItems", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Hide the window for N frames while allowing items to be submitted so we can measure their size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2853 + } + }, + { + "name": "HiddenFramesForRenderOnly", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Hide the window until frame N at Render() time only" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2854 + } + }, + { + "name": "DisableInputsFrames", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// Disable window interactions for N frames" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2855 + } + }, + { + "name": "SetWindowPosAllowFlags", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "comments": { + "attached": "// store acceptable condition flags for SetNextWindowPos() use." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2856 + } + }, + { + "name": "SetWindowSizeAllowFlags", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "comments": { + "attached": "// store acceptable condition flags for SetNextWindowSize() use." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2857 + } + }, + { + "name": "SetWindowCollapsedAllowFlags", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "comments": { + "attached": "// store acceptable condition flags for SetNextWindowCollapsed() use." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2858 + } + }, + { + "name": "SetWindowDockAllowFlags", + "is_array": false, + "width": 8, + "is_anonymous": false, + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "comments": { + "attached": "// store acceptable condition flags for SetNextWindowDock() use." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2859 + } + }, + { + "name": "SetWindowPosVal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2860 + } + }, + { + "name": "SetWindowPosPivot", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// store window pivot for positioning. ImVec2(0, 0) when positioning from top-left corner; ImVec2(0.5f, 0.5f) for centering; ImVec2(1, 1) for bottom right." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2861 + } + }, + { + "name": "IDStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiID", + "description": { + "kind": "User", + "name": "ImVector_ImGuiID" + } + }, + "comments": { + "attached": "// ID stack. ID are hashes seeded with the value at the top of the stack. (In theory this should be in the TempData structure)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2863 + } + }, + { + "name": "DC", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowTempData", + "description": { + "kind": "User", + "name": "ImGuiWindowTempData" + } + }, + "comments": { + "attached": "// Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the \"DC\" variable name." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2864 + } + }, + { + "name": "OuterRectClipped", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "preceding": [ + "// The best way to understand what those rectangles are is to use the 'Metrics->Tools->Show Windows Rectangles' viewer.", + "// The main 'OuterRect', omitted as a field, is window->Rect()." + ], + "attached": "// == Window->Rect() just after setup in Begin(). == window->Rect() for root window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2868 + } + }, + { + "name": "InnerRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Inner rectangle (omit title bar, menu bar, scroll bar)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2869 + } + }, + { + "name": "InnerClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// == InnerRect shrunk by WindowPadding*0.5f on each side, clipped within viewport or parent clip rect." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2870 + } + }, + { + "name": "WorkRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Initially covers the whole scrolling region. Reduced by containers e.g columns/tables when active. Shrunk by WindowPadding*1.0f on each side. This is meant to replace ContentRegionRect over time (from 1.71+ onward)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2871 + } + }, + { + "name": "ParentWorkRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Backup of WorkRect before entering a container such as columns/tables. Used by e.g. SpanAllColumns functions to easily access. Stacked containers are responsible for maintaining this. // FIXME-WORKRECT: Could be a stack?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2872 + } + }, + { + "name": "ClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Current clipping/scissoring rectangle, evolve as we are using PushClipRect(), etc. == DrawList->clip_rect_stack.back()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2873 + } + }, + { + "name": "ContentRegionRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// FIXME: This is currently confusing/misleading. It is essentially WorkRect but not handling of scrolling. We currently rely on it as right/bottom aligned sizing operation need some size to rely on." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2874 + } + }, + { + "name": "HitTestHoleSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2ih", + "description": { + "kind": "User", + "name": "ImVec2ih" + } + }, + "comments": { + "attached": "// Define an optional rectangular hole where mouse will pass-through the window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2875 + } + }, + { + "name": "HitTestHoleOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2ih", + "description": { + "kind": "User", + "name": "ImVec2ih" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2876 + } + }, + { + "name": "LastFrameActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last frame number the window was Active." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2878 + } + }, + { + "name": "LastFrameJustFocused", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Last frame number the window was made Focused." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2879 + } + }, + { + "name": "LastTimeActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Last timestamp the window was Active (using float as we don't need high precision there)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2880 + } + }, + { + "name": "ItemWidthDefault", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2881 + } + }, + { + "name": "StateStorage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2882 + } + }, + { + "name": "ColumnsStorage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiOldColumns", + "description": { + "kind": "User", + "name": "ImVector_ImGuiOldColumns" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2883 + } + }, + { + "name": "FontWindowScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// User scale multiplier per-window, via SetWindowFontScale()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2884 + } + }, + { + "name": "FontWindowScaleParents", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2885 + } + }, + { + "name": "FontRefSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// This is a copy of window->CalcFontSize() at the time of Begin(), trying to phase out CalcFontSize() especially as it may be called on non-current window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2886 + } + }, + { + "name": "SettingsOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Offset into SettingsWindows[] (offsets are always valid as we only grow the array from the back)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2887 + } + }, + { + "name": "DrawList", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "comments": { + "attached": "// == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2889 + } + }, + { + "name": "DrawListInst", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawList", + "description": { + "kind": "User", + "name": "ImDrawList" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2890 + } + }, + { + "name": "ParentWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// If we are a child _or_ popup _or_ docked window, this is pointing to our parent. Otherwise NULL." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2891 + } + }, + { + "name": "ParentWindowInBeginStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2892 + } + }, + { + "name": "RootWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Point to ourself or first ancestor that is not a child window. Doesn't cross through popups/dock nodes." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2893 + } + }, + { + "name": "RootWindowPopupTree", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Point to ourself or first ancestor that is not a child window. Cross through popups parent<>child." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2894 + } + }, + { + "name": "RootWindowDockTree", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Point to ourself or first ancestor that is not a child window. Cross through dock nodes." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2895 + } + }, + { + "name": "RootWindowForTitleBarHighlight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Point to ourself or first ancestor which will display TitleBgActive color when this window is active." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2896 + } + }, + { + "name": "RootWindowForNav", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Point to ourself or first ancestor which doesn't have the NavFlattened flag." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2897 + } + }, + { + "name": "ParentWindowForFocusRoute", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Set to manual link a window to its logical parent so that Shortcut() chain are honoerd (e.g. Tool linked to Document)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2898 + } + }, + { + "name": "NavLastChildNavWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// When going to the menu bar, we remember the child window we came from. (This could probably be made implicit if we kept g.Windows sorted by last focused including child window.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2900 + } + }, + { + "name": "NavLastIds", + "is_array": true, + "array_bounds": "ImGuiNavLayer_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImGuiID[ImGuiNavLayer_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiNavLayer_COUNT", + "inner_type": { + "kind": "User", + "name": "ImGuiID" + } + } + }, + "comments": { + "attached": "// Last known NavId for this window, per layer (0/1)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2901 + } + }, + { + "name": "NavRectRel", + "is_array": true, + "array_bounds": "ImGuiNavLayer_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImRect[ImGuiNavLayer_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiNavLayer_COUNT", + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "comments": { + "attached": "// Reference rectangle, in window relative space" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2902 + } + }, + { + "name": "NavPreferredScoringPosRel", + "is_array": true, + "array_bounds": "ImGuiNavLayer_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImVec2[ImGuiNavLayer_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiNavLayer_COUNT", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "comments": { + "attached": "// Preferred X/Y position updated when moving on a given axis, reset to FLT_MAX." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2903 + } + }, + { + "name": "NavRootFocusScopeId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Focus Scope ID at the time of Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2904 + } + }, + { + "name": "MemoryDrawListIdxCapacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Backup of last idx/vtx count, so when waking up the window we can preallocate and avoid iterative alloc/copy" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2906 + } + }, + { + "name": "MemoryDrawListVtxCapacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2907 + } + }, + { + "name": "MemoryCompacted", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when window extraneous data have been garbage collected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2908 + } + }, + { + "name": "DockIsActive", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Docking" + ], + "attached": "// When docking artifacts are actually visible. When this is set, DockNode is guaranteed to be != NULL. ~~ (DockNode != NULL) && (DockNode->Windows.Size > 1)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2911 + } + }, + { + "name": "DockNodeIsVisible", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2912 + } + }, + { + "name": "DockTabIsVisible", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Is our window visible this frame? ~~ is the corresponding tab selected?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2913 + } + }, + { + "name": "DockTabWantClose", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2914 + } + }, + { + "name": "DockOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// Order of the last time the window was visible within its DockNode. This is used to reorder windows that are reappearing on the same frame. Same value between windows that were active and windows that were none are possible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2915 + } + }, + { + "name": "DockStyle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindowDockStyle", + "description": { + "kind": "User", + "name": "ImGuiWindowDockStyle" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2916 + } + }, + { + "name": "DockNode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "comments": { + "attached": "// Which node are we docked into. Important: Prefer testing DockIsActive in many cases as this will still be set when the dock node is hidden." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2917 + } + }, + { + "name": "DockNodeAsHost", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "comments": { + "attached": "// Which node are we owning (for parent windows)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2918 + } + }, + { + "name": "DockId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Backup of last valid DockNode->ID, so single window remember their dock node id even when they are not bound any more" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2919 + } + } + ], + "comments": { + "preceding": [ + "// Storage for one window" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2790 + } + }, + { + "name": "ImGuiTabItem", + "original_fully_qualified_name": "ImGuiTabItem", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2965 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2966 + } + }, + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// When TabItem is part of a DockNode's TabBar, we hold on to a window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2967 + } + }, + { + "name": "LastFrameVisible", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2968 + } + }, + { + "name": "LastFrameSelected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// This allows us to infer an ordered list of the last activated tabs with little maintenance" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2969 + } + }, + { + "name": "Offset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Position relative to beginning of tab" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2970 + } + }, + { + "name": "Width", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Width currently displayed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2971 + } + }, + { + "name": "ContentWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Width of label + padding, stored during BeginTabItem() call (misnamed as \"Content\" would normally imply width of label only)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2972 + } + }, + { + "name": "RequestedWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Width optionally requested by caller, -1.0f is unused" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2973 + } + }, + { + "name": "NameOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS32", + "description": { + "kind": "User", + "name": "ImS32" + } + }, + "comments": { + "attached": "// When Window==NULL, offset to name within parent ImGuiTabBar::TabsNames" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2974 + } + }, + { + "name": "BeginOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// BeginTabItem() order, used to re-order tabs after toggling ImGuiTabBarFlags_Reorderable" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2975 + } + }, + { + "name": "IndexDuringLayout", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Index only used during TabBarLayout(). Tabs gets reordered so 'Tabs[n].IndexDuringLayout == n' but may mismatch during additions." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2976 + } + }, + { + "name": "WantClose", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Marked as closed by SetTabItemClosed()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2977 + } + } + ], + "comments": { + "preceding": [ + "// Storage for one active tab item (sizeof() 48 bytes)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2963 + } + }, + { + "name": "ImGuiTabBar", + "original_fully_qualified_name": "ImGuiTabBar", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Window", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2985 + } + }, + { + "name": "Tabs", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTabItem", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTabItem" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2986 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTabBarFlags", + "description": { + "kind": "User", + "name": "ImGuiTabBarFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2987 + } + }, + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Zero for tab-bars used by docking" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2988 + } + }, + { + "name": "SelectedTabId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Selected tab/window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2989 + } + }, + { + "name": "NextSelectedTabId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Next selected tab/window. Will also trigger a scrolling animation" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2990 + } + }, + { + "name": "VisibleTabId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2991 + } + }, + { + "name": "CurrFrameVisible", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2992 + } + }, + { + "name": "PrevFrameVisible", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2993 + } + }, + { + "name": "BarRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2994 + } + }, + { + "name": "BarRectPrevWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Backup of previous width. When width change we enforce keep horizontal scroll on focused tab." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2995 + } + }, + { + "name": "CurrTabsContentsHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2996 + } + }, + { + "name": "PrevTabsContentsHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Record the height of contents submitted below the tab bar" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2997 + } + }, + { + "name": "WidthAllTabs", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Actual width of all tabs (locked during layout)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2998 + } + }, + { + "name": "WidthAllTabsIdeal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Ideal width if all tabs were visible and not clipped" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2999 + } + }, + { + "name": "ScrollingAnim", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3000 + } + }, + { + "name": "ScrollingTarget", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3001 + } + }, + { + "name": "ScrollingTargetDistToVisibility", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3002 + } + }, + { + "name": "ScrollingSpeed", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3003 + } + }, + { + "name": "ScrollingRectMinX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3004 + } + }, + { + "name": "ScrollingRectMaxX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3005 + } + }, + { + "name": "SeparatorMinX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3006 + } + }, + { + "name": "SeparatorMaxX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3007 + } + }, + { + "name": "ReorderRequestTabId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3008 + } + }, + { + "name": "ReorderRequestOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3009 + } + }, + { + "name": "BeginCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3010 + } + }, + { + "name": "WantLayout", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3011 + } + }, + { + "name": "VisibleTabWasSubmitted", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3012 + } + }, + { + "name": "TabsAddedNew", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to true when a new tab item or button has been added to the tab bar during last frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3013 + } + }, + { + "name": "ScrollButtonEnabled", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3014 + } + }, + { + "name": "TabsActiveCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Number of tabs submitted this frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3015 + } + }, + { + "name": "LastTabItemIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Index of last BeginTabItem() tab for use by EndTabItem()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3016 + } + }, + { + "name": "ItemSpacingY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3017 + } + }, + { + "name": "FramePadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// style.FramePadding locked at the time of BeginTabBar()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3018 + } + }, + { + "name": "BackupCursorPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3019 + } + }, + { + "name": "TabsNames", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextBuffer", + "description": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + }, + "comments": { + "attached": "// For non-docking tab bar we re-append names in a contiguous buffer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3020 + } + } + ], + "comments": { + "preceding": [ + "// Storage for a tab bar (sizeof() 160 bytes)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2983 + } + }, + { + "name": "ImGuiTableColumn", + "original_fully_qualified_name": "ImGuiTableColumn", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnFlags", + "description": { + "kind": "User", + "name": "ImGuiTableColumnFlags" + } + }, + "comments": { + "attached": "// Flags after some patching (not directly same as provided by user). See ImGuiTableColumnFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3038 + } + }, + { + "name": "WidthGiven", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Final/actual width visible == (MaxX - MinX), locked in TableUpdateLayout(). May be > WidthRequest to honor minimum width, may be < WidthRequest to honor shrinking columns down in tight space." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3039 + } + }, + { + "name": "MinX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Absolute positions" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3040 + } + }, + { + "name": "MaxX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3041 + } + }, + { + "name": "WidthRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Master width absolute value when !(Flags & _WidthStretch). When Stretch this is derived every frame from StretchWeight in TableUpdateLayout()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3042 + } + }, + { + "name": "WidthAuto", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Automatic width" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3043 + } + }, + { + "name": "WidthMax", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Maximum width (FIXME: overwritten by each instance)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3044 + } + }, + { + "name": "StretchWeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Master width weight when (Flags & _WidthStretch). Often around ~1.0f initially." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3045 + } + }, + { + "name": "InitStretchWeightOrWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Value passed to TableSetupColumn(). For Width it is a content width (_without padding_)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3046 + } + }, + { + "name": "ClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Clipping rectangle for the column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3047 + } + }, + { + "name": "UserID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Optional, value passed to TableSetupColumn()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3048 + } + }, + { + "name": "WorkMinX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Contents region min ~(MinX + CellPaddingX + CellSpacingX1) == cursor start position when entering column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3049 + } + }, + { + "name": "WorkMaxX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Contents region max ~(MaxX - CellPaddingX - CellSpacingX2)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3050 + } + }, + { + "name": "ItemWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Current item width for the column, preserved across rows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3051 + } + }, + { + "name": "ContentMaxXFrozen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Contents maximum position for frozen rows (apart from headers), from which we can infer content width." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3052 + } + }, + { + "name": "ContentMaxXUnfrozen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3053 + } + }, + { + "name": "ContentMaxXHeadersUsed", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Contents maximum position for headers rows (regardless of freezing). TableHeader() automatically softclip itself + report ideal desired size, to avoid creating extraneous draw calls" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3054 + } + }, + { + "name": "ContentMaxXHeadersIdeal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3055 + } + }, + { + "name": "NameOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Offset into parent ColumnsNames[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3056 + } + }, + { + "name": "DisplayOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index within Table's IndexToDisplayOrder[] (column may be reordered by users)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3057 + } + }, + { + "name": "IndexWithinEnabledSet", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index within enabled/visible set (<= IndexToDisplayOrder)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3058 + } + }, + { + "name": "PrevEnabledColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of prev enabled/visible column within Columns[], -1 if first enabled/visible column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3059 + } + }, + { + "name": "NextEnabledColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of next enabled/visible column within Columns[], -1 if last enabled/visible column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3060 + } + }, + { + "name": "SortOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of this column within sort specs, -1 if not sorting on this column, 0 for single-sort, may be >0 on multi-sort" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3061 + } + }, + { + "name": "DrawChannelCurrent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableDrawChannelIdx", + "description": { + "kind": "User", + "name": "ImGuiTableDrawChannelIdx" + } + }, + "comments": { + "attached": "// Index within DrawSplitter.Channels[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3062 + } + }, + { + "name": "DrawChannelFrozen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableDrawChannelIdx", + "description": { + "kind": "User", + "name": "ImGuiTableDrawChannelIdx" + } + }, + "comments": { + "attached": "// Draw channels for frozen rows (often headers)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3063 + } + }, + { + "name": "DrawChannelUnfrozen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableDrawChannelIdx", + "description": { + "kind": "User", + "name": "ImGuiTableDrawChannelIdx" + } + }, + "comments": { + "attached": "// Draw channels for unfrozen rows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3064 + } + }, + { + "name": "IsEnabled", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// IsUserEnabled && (Flags & ImGuiTableColumnFlags_Disabled) == 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3065 + } + }, + { + "name": "IsUserEnabled", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Is the column not marked Hidden by the user? (unrelated to being off view, e.g. clipped by scrolling)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3066 + } + }, + { + "name": "IsUserEnabledNextFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3067 + } + }, + { + "name": "IsVisibleX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Is actually in view (e.g. overlapping the host window clipping rectangle, not scrolled)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3068 + } + }, + { + "name": "IsVisibleY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3069 + } + }, + { + "name": "IsRequestOutput", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Return value for TableSetColumnIndex() / TableNextColumn(): whether we request user to output contents or not." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3070 + } + }, + { + "name": "IsSkipItems", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Do we want item submissions to this column to be completely ignored (no layout will happen)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3071 + } + }, + { + "name": "IsPreserveWidthAuto", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3072 + } + }, + { + "name": "NavLayerCurrent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// ImGuiNavLayer in 1 byte" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3073 + } + }, + { + "name": "AutoFitQueue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Queue of 8 values for the next 8 frames to request auto-fit" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3074 + } + }, + { + "name": "CannotSkipItemsQueue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Queue of 8 values for the next 8 frames to disable Clipped/SkipItem" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3075 + } + }, + { + "name": "SortDirection", + "is_array": false, + "width": 2, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3076 + } + }, + { + "name": "SortDirectionsAvailCount", + "is_array": false, + "width": 2, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Number of available sort directions (0 to 3)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3077 + } + }, + { + "name": "SortDirectionsAvailMask", + "is_array": false, + "width": 4, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Mask of available sort directions (1-bit each)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3078 + } + }, + { + "name": "SortDirectionsAvailList", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// Ordered list of available sort directions (2-bits each, total 8-bits)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3079 + } + } + ], + "comments": { + "preceding": [ + "// [Internal] sizeof() ~ 112", + "// We use the terminology \"Enabled\" to refer to a column that is not Hidden by user/api.", + "// We use the terminology \"Clipped\" to refer to a column that is out of sight because of scrolling/clipping.", + "// This is in contrast with some user-facing api such as IsItemVisible() / IsRectVisible() which use \"Visible\" to mean \"not clipped\"." + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui_internal.h", + "line": 3036 + } + }, + { + "name": "ImGuiTableCellData", + "original_fully_qualified_name": "ImGuiTableCellData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "BgColor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// Actual color" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3098 + } + }, + { + "name": "Column", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Column number" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3099 + } + } + ], + "comments": { + "preceding": [ + "// Transient cell data stored per row.", + "// sizeof() ~ 6 bytes" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3096 + } + }, + { + "name": "ImGuiTableHeaderData", + "original_fully_qualified_name": "ImGuiTableHeaderData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Index", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Column index" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3107 + } + }, + { + "name": "TextColor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3108 + } + }, + { + "name": "BgColor0", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3109 + } + }, + { + "name": "BgColor1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3110 + } + } + ], + "comments": { + "preceding": [ + "// Parameters for TableAngledHeadersRowEx()", + "// This may end up being refactored for more general purpose.", + "// sizeof() ~ 12 bytes" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3105 + } + }, + { + "name": "ImGuiTableInstanceData", + "original_fully_qualified_name": "ImGuiTableInstanceData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "TableInstanceID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3117 + } + }, + { + "name": "LastOuterHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Outer height from last frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3118 + } + }, + { + "name": "LastTopHeadersRowHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Height of first consecutive header rows from last frame (FIXME: this is used assuming consecutive headers are in same frozen set)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3119 + } + }, + { + "name": "LastFrozenHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Height of frozen section from last frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3120 + } + }, + { + "name": "HoveredRowLast", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Index of row which was hovered last frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3121 + } + }, + { + "name": "HoveredRowNext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Index of row hovered this frame, set after encountering it." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3122 + } + } + ], + "comments": { + "preceding": [ + "// Per-instance data that needs preserving across frames (seemingly most others do not need to be preserved aside from debug needs. Does that means they could be moved to ImGuiTableTempData?)", + "// sizeof() ~ 24 bytes" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3115 + } + }, + { + "name": "ImGuiTable", + "original_fully_qualified_name": "ImGuiTable", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3130 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3131 + } + }, + { + "name": "RawData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Single allocation to hold Columns[], DisplayOrderToIndex[], and RowCellData[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3132 + } + }, + { + "name": "TempData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableTempData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableTempData" + } + } + }, + "comments": { + "attached": "// Transient data while table is active. Point within g.CurrentTableStack[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3133 + } + }, + { + "name": "Columns", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImSpan_ImGuiTableColumn", + "description": { + "kind": "User", + "name": "ImSpan_ImGuiTableColumn" + } + }, + "comments": { + "attached": "// Point within RawData[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3134 + } + }, + { + "name": "DisplayOrderToIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImSpan_ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImSpan_ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Point within RawData[]. Store display order of columns (when not reordered, the values are 0...Count-1)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3135 + } + }, + { + "name": "RowCellData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImSpan_ImGuiTableCellData", + "description": { + "kind": "User", + "name": "ImSpan_ImGuiTableCellData" + } + }, + "comments": { + "attached": "// Point within RawData[]. Store cells background requests for current row." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3136 + } + }, + { + "name": "EnabledMaskByDisplayOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImBitArrayPtr", + "description": { + "kind": "User", + "name": "ImBitArrayPtr" + } + }, + "comments": { + "attached": "// Column DisplayOrder -> IsEnabled map" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3137 + } + }, + { + "name": "EnabledMaskByIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImBitArrayPtr", + "description": { + "kind": "User", + "name": "ImBitArrayPtr" + } + }, + "comments": { + "attached": "// Column Index -> IsEnabled map (== not hidden by user/api) in a format adequate for iterating column without touching cold data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3138 + } + }, + { + "name": "VisibleMaskByIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImBitArrayPtr", + "description": { + "kind": "User", + "name": "ImBitArrayPtr" + } + }, + "comments": { + "attached": "// Column Index -> IsVisibleX|IsVisibleY map (== not hidden by user/api && not hidden by scrolling/cliprect)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3139 + } + }, + { + "name": "SettingsLoadedFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "comments": { + "attached": "// Which data were loaded from the .ini file (e.g. when order is not altered we won't save order)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3140 + } + }, + { + "name": "SettingsOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Offset in g.SettingsTables" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3141 + } + }, + { + "name": "LastFrameActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3142 + } + }, + { + "name": "ColumnsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of columns declared in BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3143 + } + }, + { + "name": "CurrentRow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3144 + } + }, + { + "name": "CurrentColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3145 + } + }, + { + "name": "InstanceCurrent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Count of BeginTable() calls with same ID in the same frame (generally 0). This is a little bit similar to BeginCount for a window, but multiple tables with the same ID are multiple tables, they are just synced." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3146 + } + }, + { + "name": "InstanceInteracted", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Mark which instance (generally 0) of the same ID is being interacted with" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3147 + } + }, + { + "name": "RowPosY1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3148 + } + }, + { + "name": "RowPosY2", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3149 + } + }, + { + "name": "RowMinHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Height submitted to TableNextRow()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3150 + } + }, + { + "name": "RowCellPaddingY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Top and bottom padding. Reloaded during row change." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3151 + } + }, + { + "name": "RowTextBaseline", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3152 + } + }, + { + "name": "RowIndentOffsetX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3153 + } + }, + { + "name": "RowFlags", + "is_array": false, + "width": 16, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableRowFlags", + "description": { + "kind": "User", + "name": "ImGuiTableRowFlags" + } + }, + "comments": { + "attached": "// Current row flags, see ImGuiTableRowFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3154 + } + }, + { + "name": "LastRowFlags", + "is_array": false, + "width": 16, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableRowFlags", + "description": { + "kind": "User", + "name": "ImGuiTableRowFlags" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3155 + } + }, + { + "name": "RowBgColorCounter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Counter for alternating background colors (can be fast-forwarded by e.g clipper), not same as CurrentRow because header rows typically don't increase this." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3156 + } + }, + { + "name": "RowBgColor", + "is_array": true, + "array_bounds": "2", + "is_anonymous": false, + "type": { + "declaration": "ImU32[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "comments": { + "attached": "// Background color override for current row." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3157 + } + }, + { + "name": "BorderColorStrong", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3158 + } + }, + { + "name": "BorderColorLight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3159 + } + }, + { + "name": "BorderX1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3160 + } + }, + { + "name": "BorderX2", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3161 + } + }, + { + "name": "HostIndentX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3162 + } + }, + { + "name": "MinColumnWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3163 + } + }, + { + "name": "OuterPaddingX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3164 + } + }, + { + "name": "CellPaddingX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Padding from each borders. Locked in BeginTable()/Layout." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3165 + } + }, + { + "name": "CellSpacingX1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Spacing between non-bordered cells. Locked in BeginTable()/Layout." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3166 + } + }, + { + "name": "CellSpacingX2", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3167 + } + }, + { + "name": "InnerWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// User value passed to BeginTable(), see comments at the top of BeginTable() for details." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3168 + } + }, + { + "name": "ColumnsGivenWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Sum of current column width" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3169 + } + }, + { + "name": "ColumnsAutoFitWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Sum of ideal column width in order nothing to be clipped, used for auto-fitting and content width submission in outer window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3170 + } + }, + { + "name": "ColumnsStretchSumWeights", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Sum of weight of all enabled stretching columns" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3171 + } + }, + { + "name": "ResizedColumnNextWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3172 + } + }, + { + "name": "ResizeLockMinContentsX2", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Lock minimum contents width while resizing down in order to not create feedback loops. But we allow growing the table." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3173 + } + }, + { + "name": "RefScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Reference scale to be able to rescale columns on font/dpi changes." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3174 + } + }, + { + "name": "AngledHeadersHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Set by TableAngledHeadersRow(), used in TableUpdateLayout()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3175 + } + }, + { + "name": "AngledHeadersSlope", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Set by TableAngledHeadersRow(), used in TableUpdateLayout()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3176 + } + }, + { + "name": "OuterRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Note: for non-scrolling table, OuterRect.Max.y is often FLT_MAX until EndTable(), unless a height has been specified in BeginTable()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3177 + } + }, + { + "name": "InnerRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// InnerRect but without decoration. As with OuterRect, for non-scrolling tables, InnerRect.Max.y is \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3178 + } + }, + { + "name": "WorkRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3179 + } + }, + { + "name": "InnerClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3180 + } + }, + { + "name": "BgClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// We use this to cpu-clip cell background color fill, evolve during the frame as we cross frozen rows boundaries" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3181 + } + }, + { + "name": "Bg0ClipRectForDrawCmd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Actual ImDrawCmd clip rect for BG0/1 channel. This tends to be == OuterWindow->ClipRect at BeginTable() because output in BG0/BG1 is cpu-clipped" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3182 + } + }, + { + "name": "Bg2ClipRectForDrawCmd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Actual ImDrawCmd clip rect for BG2 channel. This tends to be a correct, tight-fit, because output to BG2 are done by widgets relying on regular ClipRect." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3183 + } + }, + { + "name": "HostClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// This is used to check if we can eventually merge our columns draw calls into the current draw call of the current window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3184 + } + }, + { + "name": "HostBackupInnerClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Backup of InnerWindow->ClipRect during PushTableBackground()/PopTableBackground()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3185 + } + }, + { + "name": "OuterWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Parent window for the table" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3186 + } + }, + { + "name": "InnerWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "comments": { + "attached": "// Window holding the table data (== OuterWindow or a child window)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3187 + } + }, + { + "name": "ColumnsNames", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextBuffer", + "description": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + }, + "comments": { + "attached": "// Contiguous buffer holding columns names" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3188 + } + }, + { + "name": "DrawSplitter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListSplitter*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawListSplitter" + } + } + }, + "comments": { + "attached": "// Shortcut to TempData->DrawSplitter while in table. Isolate draw commands per columns to avoid switching clip rect constantly" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3189 + } + }, + { + "name": "InstanceDataFirst", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableInstanceData", + "description": { + "kind": "User", + "name": "ImGuiTableInstanceData" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3190 + } + }, + { + "name": "InstanceDataExtra", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTableInstanceData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTableInstanceData" + } + }, + "comments": { + "attached": "// FIXME-OPT: Using a small-vector pattern would be good." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3191 + } + }, + { + "name": "SortSpecsSingle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnSortSpecs", + "description": { + "kind": "User", + "name": "ImGuiTableColumnSortSpecs" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3192 + } + }, + { + "name": "SortSpecsMulti", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTableColumnSortSpecs", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTableColumnSortSpecs" + } + }, + "comments": { + "attached": "// FIXME-OPT: Using a small-vector pattern would be good." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3193 + } + }, + { + "name": "SortSpecs", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableSortSpecs", + "description": { + "kind": "User", + "name": "ImGuiTableSortSpecs" + } + }, + "comments": { + "attached": "// Public facing sorts specs, this is what we return in TableGetSortSpecs()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3194 + } + }, + { + "name": "SortSpecsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3195 + } + }, + { + "name": "ColumnsEnabledCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Number of enabled columns (<= ColumnsCount)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3196 + } + }, + { + "name": "ColumnsEnabledFixedCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Number of enabled columns using fixed width (<= ColumnsCount)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3197 + } + }, + { + "name": "DeclColumnsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Count calls to TableSetupColumn()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3198 + } + }, + { + "name": "AngledHeadersCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Count columns with angled headers" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3199 + } + }, + { + "name": "HoveredColumnBody", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of column whose visible region is being hovered. Important: == ColumnsCount when hovering empty region after the right-most column!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3200 + } + }, + { + "name": "HoveredColumnBorder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of column whose right-border is being hovered (for resizing)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3201 + } + }, + { + "name": "HighlightColumnHeader", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of column which should be highlighted." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3202 + } + }, + { + "name": "AutoFitSingleColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of single column requesting auto-fit." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3203 + } + }, + { + "name": "ResizedColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of column being resized. Reset when InstanceCurrent==0." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3204 + } + }, + { + "name": "LastResizedColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of column being resized from previous frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3205 + } + }, + { + "name": "HeldHeaderColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of column header being held." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3206 + } + }, + { + "name": "ReorderColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of column being reordered. (not cleared)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3207 + } + }, + { + "name": "ReorderColumnDir", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// -1 or +1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3208 + } + }, + { + "name": "LeftMostEnabledColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of left-most non-hidden column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3209 + } + }, + { + "name": "RightMostEnabledColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of right-most non-hidden column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3210 + } + }, + { + "name": "LeftMostStretchedColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of left-most stretched column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3211 + } + }, + { + "name": "RightMostStretchedColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of right-most stretched column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3212 + } + }, + { + "name": "ContextPopupColumn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Column right-clicked on, of -1 if opening context menu from a neutral/empty spot" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3213 + } + }, + { + "name": "FreezeRowsRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Requested frozen rows count" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3214 + } + }, + { + "name": "FreezeRowsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Actual frozen row count (== FreezeRowsRequest, or == 0 when no scrolling offset)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3215 + } + }, + { + "name": "FreezeColumnsRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Requested frozen columns count" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3216 + } + }, + { + "name": "FreezeColumnsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Actual frozen columns count (== FreezeColumnsRequest, or == 0 when no scrolling offset)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3217 + } + }, + { + "name": "RowCellDataCurrent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Index of current RowCellData[] entry in current row" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3218 + } + }, + { + "name": "DummyDrawChannel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableDrawChannelIdx", + "description": { + "kind": "User", + "name": "ImGuiTableDrawChannelIdx" + } + }, + "comments": { + "attached": "// Redirect non-visible columns here." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3219 + } + }, + { + "name": "Bg2DrawChannelCurrent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableDrawChannelIdx", + "description": { + "kind": "User", + "name": "ImGuiTableDrawChannelIdx" + } + }, + "comments": { + "attached": "// For Selectable() and other widgets drawing across columns after the freezing line. Index within DrawSplitter.Channels[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3220 + } + }, + { + "name": "Bg2DrawChannelUnfrozen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableDrawChannelIdx", + "description": { + "kind": "User", + "name": "ImGuiTableDrawChannelIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3221 + } + }, + { + "name": "NavLayer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// ImGuiNavLayer at the time of BeginTable()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3222 + } + }, + { + "name": "IsLayoutLocked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set by TableUpdateLayout() which is called when beginning the first row." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3223 + } + }, + { + "name": "IsInsideRow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when inside TableBeginRow()/TableEndRow()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3224 + } + }, + { + "name": "IsInitializing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3225 + } + }, + { + "name": "IsSortSpecsDirty", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3226 + } + }, + { + "name": "IsUsingHeaders", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when the first row had the ImGuiTableRowFlags_Headers flag." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3227 + } + }, + { + "name": "IsContextPopupOpen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when default context menu is open (also see: ContextPopupColumn, InstanceInteracted)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3228 + } + }, + { + "name": "DisableDefaultContextMenu", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Disable default context menu. You may submit your own using TableBeginContextMenuPopup()/EndPopup()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3229 + } + }, + { + "name": "IsSettingsRequestLoad", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3230 + } + }, + { + "name": "IsSettingsDirty", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when table settings have changed and needs to be reported into ImGuiTableSetttings data." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3231 + } + }, + { + "name": "IsDefaultDisplayOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when display order is unchanged from default (DisplayOrder contains 0...Count-1)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3232 + } + }, + { + "name": "IsResetAllRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3233 + } + }, + { + "name": "IsResetDisplayOrderRequest", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3234 + } + }, + { + "name": "IsUnfrozenRows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when we got past the frozen row." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3235 + } + }, + { + "name": "IsDefaultSizingPolicy", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set if user didn't explicitly set a sizing policy in BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3236 + } + }, + { + "name": "IsActiveIdAliveBeforeTable", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3237 + } + }, + { + "name": "IsActiveIdInTable", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3238 + } + }, + { + "name": "HasScrollbarYCurr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Whether ANY instance of this table had a vertical scrollbar during the current frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3239 + } + }, + { + "name": "HasScrollbarYPrev", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Whether ANY instance of this table had a vertical scrollbar during the previous." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3240 + } + }, + { + "name": "MemoryCompacted", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3241 + } + }, + { + "name": "HostSkipItems", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Backup of InnerWindow->SkipItem at the end of BeginTable(), because we will overwrite InnerWindow->SkipItem on a per-column basis" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3242 + } + } + ], + "comments": { + "preceding": [ + "// sizeof() ~ 592 bytes + heap allocs described in TableBeginInitMemory()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3128 + } + }, + { + "name": "ImGuiTableTempData", + "original_fully_qualified_name": "ImGuiTableTempData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "TableIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Index in g.Tables.Buf[] pool" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3255 + } + }, + { + "name": "LastTimeActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Last timestamp this structure was used" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3256 + } + }, + { + "name": "AngledHeadersExtraWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Used in EndTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3257 + } + }, + { + "name": "AngledHeadersRequests", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTableHeaderData", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTableHeaderData" + } + }, + "comments": { + "attached": "// Used in TableAngledHeadersRow()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3258 + } + }, + { + "name": "UserOuterSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// outer_size.x passed to BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3260 + } + }, + { + "name": "DrawSplitter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListSplitter", + "description": { + "kind": "User", + "name": "ImDrawListSplitter" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3261 + } + }, + { + "name": "HostBackupWorkRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Backup of InnerWindow->WorkRect at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3263 + } + }, + { + "name": "HostBackupParentWorkRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "comments": { + "attached": "// Backup of InnerWindow->ParentWorkRect at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3264 + } + }, + { + "name": "HostBackupPrevLineSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Backup of InnerWindow->DC.PrevLineSize at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3265 + } + }, + { + "name": "HostBackupCurrLineSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Backup of InnerWindow->DC.CurrLineSize at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3266 + } + }, + { + "name": "HostBackupCursorMaxPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Backup of InnerWindow->DC.CursorMaxPos at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3267 + } + }, + { + "name": "HostBackupColumnsOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec1", + "description": { + "kind": "User", + "name": "ImVec1" + } + }, + "comments": { + "attached": "// Backup of OuterWindow->DC.ColumnsOffset at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3268 + } + }, + { + "name": "HostBackupItemWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Backup of OuterWindow->DC.ItemWidth at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3269 + } + }, + { + "name": "HostBackupItemWidthStackSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "//Backup of OuterWindow->DC.ItemWidthStack.Size at the end of BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3270 + } + } + ], + "comments": { + "preceding": [ + "// Transient data that are only needed between BeginTable() and EndTable(), those buffers are shared (1 per level of stacked table).", + "// - Accessing those requires chasing an extra pointer so for very frequently used data we leave them in the main table structure.", + "// - We also leave out of this structure data that tend to be particularly useful for debugging/metrics.", + "// FIXME-TABLE: more transient data could be stored in a stacked ImGuiTableTempData: e.g. SortSpecs.", + "// sizeof() ~ 136 bytes." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3253 + } + }, + { + "name": "ImGuiTableColumnSettings", + "original_fully_qualified_name": "ImGuiTableColumnSettings", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "WidthOrWeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3278 + } + }, + { + "name": "UserID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3279 + } + }, + { + "name": "Index", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3280 + } + }, + { + "name": "DisplayOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3281 + } + }, + { + "name": "SortOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3282 + } + }, + { + "name": "SortDirection", + "is_array": false, + "width": 2, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3283 + } + }, + { + "name": "IsEnabled", + "is_array": false, + "width": 2, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// \"Visible\" in ini file" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3284 + } + }, + { + "name": "IsStretch", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3285 + } + } + ], + "comments": { + "preceding": [ + "// sizeof() ~ 16" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3276 + } + }, + { + "name": "ImGuiTableSettings", + "original_fully_qualified_name": "ImGuiTableSettings", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Set to 0 to invalidate/delete the setting" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3302 + } + }, + { + "name": "SaveFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "comments": { + "attached": "// Indicate data we want to save using the Resizable/Reorderable/Sortable/Hideable flags (could be using its own flags..)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3303 + } + }, + { + "name": "RefScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Reference scale to be able to rescale columns on font/dpi changes." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3304 + } + }, + { + "name": "ColumnsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3305 + } + }, + { + "name": "ColumnsCountMax", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTableColumnIdx", + "description": { + "kind": "User", + "name": "ImGuiTableColumnIdx" + } + }, + "comments": { + "attached": "// Maximum number of columns this settings instance can store, we can recycle a settings instance with lower number of columns but not higher" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3306 + } + }, + { + "name": "WantApply", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3307 + } + } + ], + "comments": { + "preceding": [ + "// This is designed to be stored in a single ImChunkStream (1 header followed by N ImGuiTableColumnSettings, etc.)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3300 + } + }, + { + "name": "ImFontLoader", + "original_fully_qualified_name": "ImFontLoader", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Name", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3996 + } + }, + { + "name": "LoaderInit", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*LoaderInit)(ImFontAtlas* atlas)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "LoaderInit", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "LoaderShutdown", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*LoaderShutdown)(ImFontAtlas* atlas)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "LoaderShutdown", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "FontSrcInit", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*FontSrcInit)(ImFontAtlas* atlas, ImFontConfig* src)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "FontSrcInit", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + { + "kind": "Type", + "name": "src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "FontSrcDestroy", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*FontSrcDestroy)(ImFontAtlas* atlas, ImFontConfig* src)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "FontSrcDestroy", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + { + "kind": "Type", + "name": "src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "FontSrcContainsGlyph", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*FontSrcContainsGlyph)(ImFontAtlas* atlas, ImFontConfig* src, ImWchar codepoint)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "codepoint", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "FontSrcContainsGlyph", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + { + "kind": "Type", + "name": "src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + { + "kind": "Type", + "name": "codepoint", + "inner_type": { + "kind": "User", + "name": "ImWchar" + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "FontBakedInit", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*FontBakedInit)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "loader_data_for_baked_src", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "FontBakedInit", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + { + "kind": "Type", + "name": "src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + { + "kind": "Type", + "name": "baked", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + { + "kind": "Type", + "name": "loader_data_for_baked_src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "FontBakedDestroy", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*FontBakedDestroy)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "loader_data_for_baked_src", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "FontBakedDestroy", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + { + "kind": "Type", + "name": "src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + { + "kind": "Type", + "name": "baked", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + { + "kind": "Type", + "name": "loader_data_for_baked_src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "FontBakedLoadGlyph", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*FontBakedLoadGlyph)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src, ImWchar codepoint, ImFontGlyph* out_glyph, float* out_advance_x)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "loader_data_for_baked_src", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "codepoint", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_glyph", + "type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_advance_x", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "FontBakedLoadGlyph", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "atlas", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + { + "kind": "Type", + "name": "src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + { + "kind": "Type", + "name": "baked", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + { + "kind": "Type", + "name": "loader_data_for_baked_src", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "codepoint", + "inner_type": { + "kind": "User", + "name": "ImWchar" + } + }, + { + "kind": "Type", + "name": "out_glyph", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + { + "kind": "Type", + "name": "out_advance_x", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h" + } + }, + { + "name": "FontBakedSrcLoaderDataSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "comments": { + "preceding": [ + "// Size of backend data, Per Baked * Per Source. Buffers are managed by core to avoid excessive allocations.", + "// FIXME: At this point the two other types of buffers may be managed by core to be consistent?" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4008 + } + } + ], + "comments": { + "preceding": [ + "// Hooks and storage for a given font backend.", + "// This structure is likely to evolve as we add support for incremental atlas updates.", + "// Conceptually this could be public, but API is still going to be evolve." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3994 + } + }, + { + "name": "ImFontAtlasRectEntry", + "original_fully_qualified_name": "ImFontAtlasRectEntry", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "TargetIndex", + "is_array": false, + "width": 20, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// When Used: ImFontAtlasRectId -> into Rects[]. When unused: index to next unused RectsIndex[] slot to consume free-list." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4047 + } + }, + { + "name": "Generation", + "is_array": false, + "width": 10, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Increased each time the entry is reused for a new rectangle." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4048 + } + }, + { + "name": "IsUsed", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4049 + } + } + ], + "comments": { + "preceding": [ + "// Packed rectangle lookup entry (we need an indirection to allow removing/reordering rectangles)", + "// User are returned ImFontAtlasRectId values which are meant to be persistent.", + "// We handle this with an indirection. While Rects[] may be in theory shuffled, compacted etc., RectsIndex[] cannot it is keyed by ImFontAtlasRectId.", + "// RectsIndex[] is used both as an index into Rects[] and an index into itself. This is basically a free-list. See ImFontAtlasBuildAllocRectIndexEntry() code.", + "// Having this also makes it easier to e.g. sort rectangles during repack." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4045 + } + }, + { + "name": "ImVector_ImFontAtlasRectEntry", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlasRectEntry*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasRectEntry" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "ImFontAtlasPostProcessData", + "original_fully_qualified_name": "ImFontAtlasPostProcessData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "FontAtlas", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4055 + } + }, + { + "name": "Font", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4056 + } + }, + { + "name": "FontSrc", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4057 + } + }, + { + "name": "FontBaked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4058 + } + }, + { + "name": "Glyph", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4059 + } + }, + { + "name": "Pixels", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "preceding": [ + "// Pixel data" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4062 + } + }, + { + "name": "Format", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4063 + } + }, + { + "name": "Pitch", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4064 + } + }, + { + "name": "Width", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4065 + } + }, + { + "name": "Height", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4066 + } + } + ], + "comments": { + "preceding": [ + "// Data available to potential texture post-processing functions" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4053 + } + }, + { + "name": "IMGUI_STB_NAMESPACEstbrp_node", + "original_fully_qualified_name": "IMGUI_STB_NAMESPACE::stbrp_node", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4071 + } + }, + { + "name": "stbrp_node", + "original_fully_qualified_name": "stbrp_node", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4074 + } + }, + { + "name": "ImVector_stbrp_node_im", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "stbrp_node_im*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "stbrp_node_im" + } + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_STB_NAMESPACE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2247 + } + }, + { + "name": "stbrp_context_opaque", + "original_fully_qualified_name": "stbrp_context_opaque", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "data", + "is_array": true, + "array_bounds": "80", + "is_anonymous": false, + "type": { + "declaration": "char[80]", + "description": { + "kind": "Array", + "bounds": "80", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4077 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4077 + } + }, + { + "name": "ImFontAtlasBuilder", + "original_fully_qualified_name": "ImFontAtlasBuilder", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "PackContext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "stbrp_context_opaque", + "description": { + "kind": "User", + "name": "stbrp_context_opaque" + } + }, + "comments": { + "attached": "// Actually 'stbrp_context' but we don't want to define this in the header file." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4082 + } + }, + { + "name": "PackNodes", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_stbrp_node_im", + "description": { + "kind": "User", + "name": "ImVector_stbrp_node_im" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4083 + } + }, + { + "name": "Rects", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImTextureRect", + "description": { + "kind": "User", + "name": "ImVector_ImTextureRect" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4084 + } + }, + { + "name": "RectsIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontAtlasRectEntry", + "description": { + "kind": "User", + "name": "ImVector_ImFontAtlasRectEntry" + } + }, + "comments": { + "attached": "// ImFontAtlasRectId -> index into Rects[]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4085 + } + }, + { + "name": "TempBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_unsigned_char", + "description": { + "kind": "User", + "name": "ImVector_unsigned_char" + } + }, + "comments": { + "attached": "// Misc scratch buffer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4086 + } + }, + { + "name": "RectsIndexFreeListStart", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// First unused entry" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4087 + } + }, + { + "name": "RectsPackedCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of packed rectangles." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4088 + } + }, + { + "name": "RectsPackedSurface", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of packed pixels. Used when compacting to heuristically find the ideal texture size." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4089 + } + }, + { + "name": "RectsDiscardedCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4090 + } + }, + { + "name": "RectsDiscardedSurface", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4091 + } + }, + { + "name": "FrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Current frame count" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4092 + } + }, + { + "name": "MaxRectSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2i", + "description": { + "kind": "User", + "name": "ImVec2i" + } + }, + "comments": { + "attached": "// Largest rectangle to pack (de-facto used as a \"minimum texture size\")" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4093 + } + }, + { + "name": "MaxRectBounds", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2i", + "description": { + "kind": "User", + "name": "ImVec2i" + } + }, + "comments": { + "attached": "// Bottom-right most used pixels" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4094 + } + }, + { + "name": "LockDisableResize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Disable resizing texture" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4095 + } + }, + { + "name": "PreloadedAllGlyphsRanges", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when missing ImGuiBackendFlags_RendererHasTextures features forces atlas to preload everything." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4096 + } + }, + { + "name": "BakedPool", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImStableVector_ImFontBaked_32", + "description": { + "kind": "User", + "name": "ImStableVector_ImFontBaked_32" + } + }, + "comments": { + "preceding": [ + "// Cache of all ImFontBaked" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4099 + } + }, + { + "name": "BakedMap", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// BakedId --> ImFontBaked*" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4100 + } + }, + { + "name": "BakedDiscardedCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4101 + } + }, + { + "name": "PackIdMouseCursors", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "comments": { + "preceding": [ + "// Custom rectangle identifiers" + ], + "attached": "// White pixel + mouse cursors. Also happen to be fallback in case of packing failure." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4104 + } + }, + { + "name": "PackIdLinesTexData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4105 + } + } + ], + "comments": { + "preceding": [ + "// Internal storage for incrementally packing and building a ImFontAtlas" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4080 + } + } + ], + "functions": [ + { + "name": "cImHashData", + "original_fully_qualified_name": "ImHashData", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Helpers: Hashing" + ], + "attached": "// Implied seed = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 378 + } + }, + { + "name": "cImHashDataEx", + "original_fully_qualified_name": "ImHashData", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "seed", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 378 + } + }, + { + "name": "cImHashStr", + "original_fully_qualified_name": "ImHashStr", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied data_size = 0, seed = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 379 + } + }, + { + "name": "cImHashStrEx", + "original_fully_qualified_name": "ImHashStr", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "seed", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 379 + } + }, + { + "name": "cImAlphaBlendColors", + "original_fully_qualified_name": "ImAlphaBlendColors", + "return_type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "arguments": [ + { + "name": "col_a", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_b", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Helpers: Color Blending" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 387 + } + }, + { + "name": "cImIsPowerOfTwo", + "original_fully_qualified_name": "ImIsPowerOfTwo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Helpers: Bit manipulation" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 390 + } + }, + { + "name": "cImIsPowerOfTwoImU64", + "original_fully_qualified_name": "ImIsPowerOfTwo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 391 + } + }, + { + "name": "cImUpperPowerOfTwo", + "original_fully_qualified_name": "ImUpperPowerOfTwo", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 392 + } + }, + { + "name": "cImCountSetBits", + "original_fully_qualified_name": "ImCountSetBits", + "return_type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 393 + } + }, + { + "name": "cImStricmp", + "original_fully_qualified_name": "ImStricmp", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "str1", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str2", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Case insensitive compare." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 398 + } + }, + { + "name": "cImStrnicmp", + "original_fully_qualified_name": "ImStrnicmp", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "str1", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str2", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Case insensitive compare to a certain count." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 399 + } + }, + { + "name": "cImStrncpy", + "original_fully_qualified_name": "ImStrncpy", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "dst", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Copy to a certain count and always zero terminate (strncpy doesn't)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 400 + } + }, + { + "name": "cImStrdup", + "original_fully_qualified_name": "ImStrdup", + "return_type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "arguments": [ + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Duplicate a string." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 401 + } + }, + { + "name": "cImMemdup", + "original_fully_qualified_name": "ImMemdup", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "src", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Duplicate a chunk of memory." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 402 + } + }, + { + "name": "cImStrdupcpy", + "original_fully_qualified_name": "ImStrdupcpy", + "return_type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "arguments": [ + { + "name": "dst", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_dst_size", + "type": { + "declaration": "size_t*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "size_t" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Copy in provided buffer, recreate buffer if needed." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 403 + } + }, + { + "name": "cImStrchrRange", + "original_fully_qualified_name": "ImStrchrRange", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "str_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Find first occurrence of 'c' in string range." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 404 + } + }, + { + "name": "cImStreolRange", + "original_fully_qualified_name": "ImStreolRange", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// End end-of-line" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 405 + } + }, + { + "name": "cImStristr", + "original_fully_qualified_name": "ImStristr", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "haystack", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "haystack_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "needle", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "needle_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Find a substring in a string range." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 406 + } + }, + { + "name": "cImStrTrimBlanks", + "original_fully_qualified_name": "ImStrTrimBlanks", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Remove leading and trailing blanks from a buffer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 407 + } + }, + { + "name": "cImStrSkipBlank", + "original_fully_qualified_name": "ImStrSkipBlank", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Find first non-blank character." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 408 + } + }, + { + "name": "cImStrlenW", + "original_fully_qualified_name": "ImStrlenW", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "str", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Computer string length (ImWchar string)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 409 + } + }, + { + "name": "cImStrbol", + "original_fully_qualified_name": "ImStrbol", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "buf_mid_line", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Find beginning-of-line" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 410 + } + }, + { + "name": "cImToUpper", + "original_fully_qualified_name": "ImToUpper", + "return_type": { + "declaration": "char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "arguments": [ + { + "name": "c", + "type": { + "declaration": "char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 412 + } + }, + { + "name": "cImCharIsBlankA", + "original_fully_qualified_name": "ImCharIsBlankA", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "c", + "type": { + "declaration": "char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 413 + } + }, + { + "name": "cImCharIsBlankW", + "original_fully_qualified_name": "ImCharIsBlankW", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "c", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 414 + } + }, + { + "name": "cImCharIsXdigitA", + "original_fully_qualified_name": "ImCharIsXdigitA", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "c", + "type": { + "declaration": "char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 415 + } + }, + { + "name": "cImFormatString", + "original_fully_qualified_name": "ImFormatString", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg3__", + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Helpers: Formatting" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 419 + } + }, + { + "name": "cImFormatStringV", + "original_fully_qualified_name": "ImFormatStringV", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 420 + } + }, + { + "name": "cImFormatStringToTempBuffer", + "original_fully_qualified_name": "ImFormatStringToTempBuffer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "out_buf", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_buf_end", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg3__", + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 421 + } + }, + { + "name": "cImFormatStringToTempBufferV", + "original_fully_qualified_name": "ImFormatStringToTempBufferV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "out_buf", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_buf_end", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 422 + } + }, + { + "name": "cImParseFormatFindStart", + "original_fully_qualified_name": "ImParseFormatFindStart", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 423 + } + }, + { + "name": "cImParseFormatFindEnd", + "original_fully_qualified_name": "ImParseFormatFindEnd", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 424 + } + }, + { + "name": "cImParseFormatTrimDecorations", + "original_fully_qualified_name": "ImParseFormatTrimDecorations", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 425 + } + }, + { + "name": "cImParseFormatSanitizeForPrinting", + "original_fully_qualified_name": "ImParseFormatSanitizeForPrinting", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt_in", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt_out", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt_out_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 426 + } + }, + { + "name": "cImParseFormatSanitizeForScanning", + "original_fully_qualified_name": "ImParseFormatSanitizeForScanning", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "fmt_in", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt_out", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt_out_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 427 + } + }, + { + "name": "cImParseFormatPrecision", + "original_fully_qualified_name": "ImParseFormatPrecision", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_value", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 428 + } + }, + { + "name": "cImTextCharToUtf8", + "original_fully_qualified_name": "ImTextCharToUtf8", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "out_buf", + "type": { + "declaration": "char[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "5", + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Helpers: UTF-8 <> wchar conversions" + ], + "attached": "// return output UTF-8 bytes count" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 431 + } + }, + { + "name": "cImTextStrToUtf8", + "original_fully_qualified_name": "ImTextStrToUtf8", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "out_buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_buf_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return output UTF-8 bytes count" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 432 + } + }, + { + "name": "cImTextCharFromUtf8", + "original_fully_qualified_name": "ImTextCharFromUtf8", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "out_char", + "type": { + "declaration": "unsigned int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// read one character. return input UTF-8 bytes count" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 433 + } + }, + { + "name": "cImTextStrFromUtf8", + "original_fully_qualified_name": "ImTextStrFromUtf8", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "out_buf", + "type": { + "declaration": "ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_buf_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied in_remaining = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 434 + } + }, + { + "name": "cImTextStrFromUtf8Ex", + "original_fully_qualified_name": "ImTextStrFromUtf8", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "out_buf", + "type": { + "declaration": "ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_buf_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_remaining", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return input UTF-8 bytes count" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 434 + } + }, + { + "name": "cImTextCountCharsFromUtf8", + "original_fully_qualified_name": "ImTextCountCharsFromUtf8", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "in_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return number of UTF-8 code-points (NOT bytes count)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 435 + } + }, + { + "name": "cImTextCountUtf8BytesFromChar", + "original_fully_qualified_name": "ImTextCountUtf8BytesFromChar", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "in_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return number of bytes to express one char in UTF-8" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 436 + } + }, + { + "name": "cImTextCountUtf8BytesFromStr", + "original_fully_qualified_name": "ImTextCountUtf8BytesFromStr", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "in_text", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return number of bytes to express string in UTF-8" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 437 + } + }, + { + "name": "cImTextFindPreviousUtf8Codepoint", + "original_fully_qualified_name": "ImTextFindPreviousUtf8Codepoint", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "in_text_start", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_curr", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return previous UTF-8 code-point." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 438 + } + }, + { + "name": "cImTextCountLines", + "original_fully_qualified_name": "ImTextCountLines", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "in_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return number of lines taken by text. trailing carriage return doesn't count as an extra line." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 439 + } + }, + { + "name": "cImFileOpen", + "original_fully_qualified_name": "ImFileOpen", + "return_type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "arguments": [ + { + "name": "__unnamed_arg0__", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg1__", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 445 + } + }, + { + "name": "cImFileClose", + "original_fully_qualified_name": "ImFileClose", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "__unnamed_arg0__", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 446 + } + }, + { + "name": "cImFileGetSize", + "original_fully_qualified_name": "ImFileGetSize", + "return_type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "arguments": [ + { + "name": "__unnamed_arg0__", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 447 + } + }, + { + "name": "cImFileRead", + "original_fully_qualified_name": "ImFileRead", + "return_type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "arguments": [ + { + "name": "__unnamed_arg0__", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg1__", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg2__", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg3__", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 448 + } + }, + { + "name": "cImFileWrite", + "original_fully_qualified_name": "ImFileWrite", + "return_type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "arguments": [ + { + "name": "__unnamed_arg0__", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg1__", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg2__", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg3__", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 449 + } + }, + { + "name": "cImFileOpen", + "original_fully_qualified_name": "ImFileOpen", + "return_type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "arguments": [ + { + "name": "filename", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "mode", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 453 + } + }, + { + "name": "cImFileClose", + "original_fully_qualified_name": "ImFileClose", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "file", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 454 + } + }, + { + "name": "cImFileGetSize", + "original_fully_qualified_name": "ImFileGetSize", + "return_type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "arguments": [ + { + "name": "file", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 455 + } + }, + { + "name": "cImFileRead", + "original_fully_qualified_name": "ImFileRead", + "return_type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "file", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 456 + } + }, + { + "name": "cImFileWrite", + "original_fully_qualified_name": "ImFileWrite", + "return_type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "file", + "type": { + "declaration": "ImFileHandle", + "description": { + "kind": "User", + "name": "ImFileHandle" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 457 + } + }, + { + "name": "cImFileLoadToMemory", + "original_fully_qualified_name": "ImFileLoadToMemory", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "filename", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "mode", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied out_file_size = NULL, padding_bytes = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 461 + } + }, + { + "name": "cImFileLoadToMemoryEx", + "original_fully_qualified_name": "ImFileLoadToMemory", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "filename", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "mode", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_file_size", + "type": { + "declaration": "size_t*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "size_t" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "padding_bytes", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 461 + } + }, + { + "name": "cImPow", + "original_fully_qualified_name": "ImPow", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 476 + } + }, + { + "name": "cImPowDouble", + "original_fully_qualified_name": "ImPow", + "return_type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "y", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 477 + } + }, + { + "name": "cImLog", + "original_fully_qualified_name": "ImLog", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 478 + } + }, + { + "name": "cImLogDouble", + "original_fully_qualified_name": "ImLog", + "return_type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 479 + } + }, + { + "name": "cImAbs", + "original_fully_qualified_name": "ImAbs", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 480 + } + }, + { + "name": "cImAbsFloat", + "original_fully_qualified_name": "ImAbs", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 481 + } + }, + { + "name": "cImAbsDouble", + "original_fully_qualified_name": "ImAbs", + "return_type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 482 + } + }, + { + "name": "cImSign", + "original_fully_qualified_name": "ImSign", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Sign operator - returns -1, 0 or 1 based on sign of argument" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 483 + } + }, + { + "name": "cImSignDouble", + "original_fully_qualified_name": "ImSign", + "return_type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 484 + } + }, + { + "name": "cImRsqrt", + "original_fully_qualified_name": "ImRsqrt", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + }, + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_SSE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 486 + } + }, + { + "name": "cImRsqrtFloat", + "original_fully_qualified_name": "ImRsqrt", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + }, + { + "condition": "ifndef", + "expression": "IMGUI_ENABLE_SSE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 488 + } + }, + { + "name": "cImRsqrtDouble", + "original_fully_qualified_name": "ImRsqrt", + "return_type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "arguments": [ + { + "name": "x", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 490 + } + }, + { + "name": "cImMin", + "original_fully_qualified_name": "ImMin", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "lhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// - Misc maths helpers" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 502 + } + }, + { + "name": "cImMax", + "original_fully_qualified_name": "ImMax", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "lhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 503 + } + }, + { + "name": "cImClamp", + "original_fully_qualified_name": "ImClamp", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "mn", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "mx", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 504 + } + }, + { + "name": "cImLerp", + "original_fully_qualified_name": "ImLerp", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "t", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 505 + } + }, + { + "name": "cImLerpImVec2", + "original_fully_qualified_name": "ImLerp", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "t", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 506 + } + }, + { + "name": "cImLerpImVec4", + "original_fully_qualified_name": "ImLerp", + "return_type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "t", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 507 + } + }, + { + "name": "cImSaturate", + "original_fully_qualified_name": "ImSaturate", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "f", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 508 + } + }, + { + "name": "cImLengthSqr", + "original_fully_qualified_name": "ImLengthSqr", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "lhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 509 + } + }, + { + "name": "cImLengthSqrImVec4", + "original_fully_qualified_name": "ImLengthSqr", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "lhs", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 510 + } + }, + { + "name": "cImInvLength", + "original_fully_qualified_name": "ImInvLength", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "lhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fail_value", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 511 + } + }, + { + "name": "cImTrunc", + "original_fully_qualified_name": "ImTrunc", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "f", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 512 + } + }, + { + "name": "cImTruncImVec2", + "original_fully_qualified_name": "ImTrunc", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 513 + } + }, + { + "name": "cImFloor", + "original_fully_qualified_name": "ImFloor", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "f", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Decent replacement for floorf()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 514 + } + }, + { + "name": "cImFloorImVec2", + "original_fully_qualified_name": "ImFloor", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 515 + } + }, + { + "name": "cImTrunc64", + "original_fully_qualified_name": "ImTrunc64", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "f", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 516 + } + }, + { + "name": "cImRound64", + "original_fully_qualified_name": "ImRound64", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "f", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 517 + } + }, + { + "name": "cImModPositive", + "original_fully_qualified_name": "ImModPositive", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 518 + } + }, + { + "name": "cImDot", + "original_fully_qualified_name": "ImDot", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 519 + } + }, + { + "name": "cImRotate", + "original_fully_qualified_name": "ImRotate", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "v", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cos_a", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sin_a", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 520 + } + }, + { + "name": "cImLinearSweep", + "original_fully_qualified_name": "ImLinearSweep", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "current", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "target", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 521 + } + }, + { + "name": "cImLinearRemapClamp", + "original_fully_qualified_name": "ImLinearRemapClamp", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "s0", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "s1", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "d0", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "d1", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 522 + } + }, + { + "name": "cImMul", + "original_fully_qualified_name": "ImMul", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "lhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rhs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 523 + } + }, + { + "name": "cImIsFloatAboveGuaranteedIntegerPrecision", + "original_fully_qualified_name": "ImIsFloatAboveGuaranteedIntegerPrecision", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "f", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 524 + } + }, + { + "name": "cImExponentialMovingAverage", + "original_fully_qualified_name": "ImExponentialMovingAverage", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "avg", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sample", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 525 + } + }, + { + "name": "cImBezierCubicCalc", + "original_fully_qualified_name": "ImBezierCubicCalc", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "t", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Helpers: Geometry" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 529 + } + }, + { + "name": "cImBezierCubicClosestPoint", + "original_fully_qualified_name": "ImBezierCubicClosestPoint", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// For curves with explicit number of segments" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 530 + } + }, + { + "name": "cImBezierCubicClosestPointCasteljau", + "original_fully_qualified_name": "ImBezierCubicClosestPointCasteljau", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tess_tol", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// For auto-tessellated curves you can use tess_tol = style.CurveTessellationTol" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 531 + } + }, + { + "name": "cImBezierQuadraticCalc", + "original_fully_qualified_name": "ImBezierQuadraticCalc", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "t", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 532 + } + }, + { + "name": "cImLineClosestPoint", + "original_fully_qualified_name": "ImLineClosestPoint", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 533 + } + }, + { + "name": "cImTriangleContainsPoint", + "original_fully_qualified_name": "ImTriangleContainsPoint", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 534 + } + }, + { + "name": "cImTriangleClosestPoint", + "original_fully_qualified_name": "ImTriangleClosestPoint", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 535 + } + }, + { + "name": "cImTriangleBarycentricCoords", + "original_fully_qualified_name": "ImTriangleBarycentricCoords", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_u", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_w", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 536 + } + }, + { + "name": "cImTriangleArea", + "original_fully_qualified_name": "ImTriangleArea", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 537 + } + }, + { + "name": "cImTriangleIsClockwise", + "original_fully_qualified_name": "ImTriangleIsClockwise", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 538 + } + }, + { + "name": "ImRect_GetCenter", + "original_fully_qualified_name": "GetCenter", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 579 + } + }, + { + "name": "ImRect_GetSize", + "original_fully_qualified_name": "GetSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 580 + } + }, + { + "name": "ImRect_GetWidth", + "original_fully_qualified_name": "GetWidth", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 581 + } + }, + { + "name": "ImRect_GetHeight", + "original_fully_qualified_name": "GetHeight", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 582 + } + }, + { + "name": "ImRect_GetArea", + "original_fully_qualified_name": "GetArea", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 583 + } + }, + { + "name": "ImRect_GetTL", + "original_fully_qualified_name": "GetTL", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "comments": { + "attached": "// Top-left" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 584 + } + }, + { + "name": "ImRect_GetTR", + "original_fully_qualified_name": "GetTR", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "comments": { + "attached": "// Top-right" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 585 + } + }, + { + "name": "ImRect_GetBL", + "original_fully_qualified_name": "GetBL", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "comments": { + "attached": "// Bottom-left" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 586 + } + }, + { + "name": "ImRect_GetBR", + "original_fully_qualified_name": "GetBR", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "comments": { + "attached": "// Bottom-right" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 587 + } + }, + { + "name": "ImRect_Contains", + "original_fully_qualified_name": "Contains", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 588 + } + }, + { + "name": "ImRect_ContainsImRect", + "original_fully_qualified_name": "Contains", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 589 + } + }, + { + "name": "ImRect_ContainsWithPad", + "original_fully_qualified_name": "ContainsWithPad", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pad", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 590 + } + }, + { + "name": "ImRect_Overlaps", + "original_fully_qualified_name": "Overlaps", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 591 + } + }, + { + "name": "ImRect_Add", + "original_fully_qualified_name": "Add", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 592 + } + }, + { + "name": "ImRect_AddImRect", + "original_fully_qualified_name": "Add", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 593 + } + }, + { + "name": "ImRect_Expand", + "original_fully_qualified_name": "Expand", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "amount", + "type": { + "declaration": "const float", + "description": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 594 + } + }, + { + "name": "ImRect_ExpandImVec2", + "original_fully_qualified_name": "Expand", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "amount", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 595 + } + }, + { + "name": "ImRect_Translate", + "original_fully_qualified_name": "Translate", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "d", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 596 + } + }, + { + "name": "ImRect_TranslateX", + "original_fully_qualified_name": "TranslateX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "dx", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 597 + } + }, + { + "name": "ImRect_TranslateY", + "original_fully_qualified_name": "TranslateY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "dy", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 598 + } + }, + { + "name": "ImRect_ClipWith", + "original_fully_qualified_name": "ClipWith", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "comments": { + "attached": "// Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 599 + } + }, + { + "name": "ImRect_ClipWithFull", + "original_fully_qualified_name": "ClipWithFull", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "comments": { + "attached": "// Full version, ensure both points are fully clipped." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 600 + } + }, + { + "name": "ImRect_Floor", + "original_fully_qualified_name": "Floor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 601 + } + }, + { + "name": "ImRect_IsInverted", + "original_fully_qualified_name": "IsInverted", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 602 + } + }, + { + "name": "ImRect_ToVec4", + "original_fully_qualified_name": "ToVec4", + "return_type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImRect", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 603 + } + }, + { + "name": "cImBitArrayGetStorageSizeInBytes", + "original_fully_qualified_name": "ImBitArrayGetStorageSizeInBytes", + "return_type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "arguments": [ + { + "name": "bitcount", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 609 + } + }, + { + "name": "cImBitArrayClearAllBits", + "original_fully_qualified_name": "ImBitArrayClearAllBits", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "arr", + "type": { + "declaration": "ImU32*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bitcount", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 610 + } + }, + { + "name": "cImBitArrayTestBit", + "original_fully_qualified_name": "ImBitArrayTestBit", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "arr", + "type": { + "declaration": "const ImU32*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU32", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 611 + } + }, + { + "name": "cImBitArrayClearBit", + "original_fully_qualified_name": "ImBitArrayClearBit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "arr", + "type": { + "declaration": "ImU32*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 612 + } + }, + { + "name": "cImBitArraySetBit", + "original_fully_qualified_name": "ImBitArraySetBit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "arr", + "type": { + "declaration": "ImU32*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 613 + } + }, + { + "name": "cImBitArraySetBitRange", + "original_fully_qualified_name": "ImBitArraySetBitRange", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "arr", + "type": { + "declaration": "ImU32*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n2", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Works on range [n..n2)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 614 + } + }, + { + "name": "ImBitVector_Create", + "original_fully_qualified_name": "Create", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImBitVector*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImBitVector" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "sz", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImBitVector", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 650 + } + }, + { + "name": "ImBitVector_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImBitVector*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImBitVector" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImBitVector", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 651 + } + }, + { + "name": "ImBitVector_TestBit", + "original_fully_qualified_name": "TestBit", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImBitVector*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImBitVector", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImBitVector", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 652 + } + }, + { + "name": "ImBitVector_SetBit", + "original_fully_qualified_name": "SetBit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImBitVector*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImBitVector" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImBitVector", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 653 + } + }, + { + "name": "ImBitVector_ClearBit", + "original_fully_qualified_name": "ClearBit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImBitVector*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImBitVector" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImBitVector", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 654 + } + }, + { + "name": "ImStableVector_ImFontBaked_32_clear", + "original_fully_qualified_name": "clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImStableVector_ImFontBaked_32*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImStableVector_ImFontBaked_32" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImStableVector_ImFontBaked_32", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 723 + } + }, + { + "name": "ImStableVector_ImFontBaked_32_resize", + "original_fully_qualified_name": "resize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImStableVector_ImFontBaked_32*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImStableVector_ImFontBaked_32" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "new_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImStableVector_ImFontBaked_32", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 724 + } + }, + { + "name": "ImStableVector_ImFontBaked_32_reserve", + "original_fully_qualified_name": "reserve", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImStableVector_ImFontBaked_32*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImStableVector_ImFontBaked_32" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "new_cap", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImStableVector_ImFontBaked_32", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 725 + } + }, + { + "name": "ImGuiTextIndex_clear", + "original_fully_qualified_name": "clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextIndex*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextIndex" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextIndex", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 805 + } + }, + { + "name": "ImGuiTextIndex_size", + "original_fully_qualified_name": "size", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextIndex*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextIndex" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextIndex", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 806 + } + }, + { + "name": "ImGuiTextIndex_get_line_begin", + "original_fully_qualified_name": "get_line_begin", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextIndex*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextIndex" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "base", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextIndex", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 807 + } + }, + { + "name": "ImGuiTextIndex_get_line_end", + "original_fully_qualified_name": "get_line_end", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextIndex*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextIndex" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "base", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextIndex", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 808 + } + }, + { + "name": "ImGuiTextIndex_append", + "original_fully_qualified_name": "append", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextIndex*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextIndex" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "base", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "new_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextIndex", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 809 + } + }, + { + "name": "cImLowerBound", + "original_fully_qualified_name": "ImLowerBound", + "return_type": { + "declaration": "ImGuiStoragePair*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStoragePair" + } + } + }, + "arguments": [ + { + "name": "in_begin", + "type": { + "declaration": "ImGuiStoragePair*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStoragePair" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_end", + "type": { + "declaration": "ImGuiStoragePair*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStoragePair" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Helper: ImGuiStorage" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 813 + } + }, + { + "name": "ImDrawListSharedData_SetCircleTessellationMaxError", + "original_fully_qualified_name": "SetCircleTessellationMaxError", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawListSharedData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawListSharedData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "max_error", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawListSharedData", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 872 + } + }, + { + "name": "ImGuiStyleVarInfo_GetVarPtr", + "original_fully_qualified_name": "GetVarPtr", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiStyleVarInfo*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStyleVarInfo", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "parent", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStyleVarInfo", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 899 + } + }, + { + "name": "ImGuiMenuColumns_Update", + "original_fully_qualified_name": "Update", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiMenuColumns*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiMenuColumns" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "spacing", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window_reappearing", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiMenuColumns", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1191 + } + }, + { + "name": "ImGuiMenuColumns_DeclColumns", + "original_fully_qualified_name": "DeclColumns", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiMenuColumns*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiMenuColumns" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "w_icon", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w_label", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w_shortcut", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w_mark", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiMenuColumns", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1192 + } + }, + { + "name": "ImGuiMenuColumns_CalcNextTotalWidth", + "original_fully_qualified_name": "CalcNextTotalWidth", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiMenuColumns*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiMenuColumns" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "update_offsets", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiMenuColumns", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1193 + } + }, + { + "name": "ImGuiInputTextDeactivatedState_ClearFreeMemory", + "original_fully_qualified_name": "ClearFreeMemory", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextDeactivatedState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextDeactivatedState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextDeactivatedState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1203 + } + }, + { + "name": "ImGuiInputTextState_ClearText", + "original_fully_qualified_name": "ClearText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1242 + } + }, + { + "name": "ImGuiInputTextState_ClearFreeMemory", + "original_fully_qualified_name": "ClearFreeMemory", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1243 + } + }, + { + "name": "ImGuiInputTextState_OnKeyPressed", + "original_fully_qualified_name": "OnKeyPressed", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "comments": { + "attached": "// Cannot be inline because we call in code in stb_textedit.h implementation" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1244 + } + }, + { + "name": "ImGuiInputTextState_OnCharPressed", + "original_fully_qualified_name": "OnCharPressed", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1245 + } + }, + { + "name": "ImGuiInputTextState_CursorAnimReset", + "original_fully_qualified_name": "CursorAnimReset", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "comments": { + "preceding": [ + "// Cursor & Selection" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1248 + } + }, + { + "name": "ImGuiInputTextState_CursorClamp", + "original_fully_qualified_name": "CursorClamp", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1249 + } + }, + { + "name": "ImGuiInputTextState_HasSelection", + "original_fully_qualified_name": "HasSelection", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1250 + } + }, + { + "name": "ImGuiInputTextState_ClearSelection", + "original_fully_qualified_name": "ClearSelection", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1251 + } + }, + { + "name": "ImGuiInputTextState_GetCursorPos", + "original_fully_qualified_name": "GetCursorPos", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1252 + } + }, + { + "name": "ImGuiInputTextState_GetSelectionStart", + "original_fully_qualified_name": "GetSelectionStart", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1253 + } + }, + { + "name": "ImGuiInputTextState_GetSelectionEnd", + "original_fully_qualified_name": "GetSelectionEnd", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1254 + } + }, + { + "name": "ImGuiInputTextState_SelectAll", + "original_fully_qualified_name": "SelectAll", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1255 + } + }, + { + "name": "ImGuiInputTextState_ReloadUserBufAndSelectAll", + "original_fully_qualified_name": "ReloadUserBufAndSelectAll", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "comments": { + "preceding": [ + "// Reload user buf (WIP #2890)", + "// If you modify underlying user-passed const char* while active you need to call this (InputText V2 may lift this)", + "// strcpy(my_buf, \"hello\");", + "// if (ImGuiInputTextState* state = ImGui::GetInputTextState(id)) // id may be ImGui::GetItemID() is last item", + "// state->ReloadUserBufAndSelectAll();" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1262 + } + }, + { + "name": "ImGuiInputTextState_ReloadUserBufAndKeepSelection", + "original_fully_qualified_name": "ReloadUserBufAndKeepSelection", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1263 + } + }, + { + "name": "ImGuiInputTextState_ReloadUserBufAndMoveToEnd", + "original_fully_qualified_name": "ReloadUserBufAndMoveToEnd", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextState", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1264 + } + }, + { + "name": "ImGuiNextWindowData_ClearFlags", + "original_fully_qualified_name": "ClearFlags", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiNextWindowData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiNextWindowData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiNextWindowData", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1325 + } + }, + { + "name": "ImGuiNextItemData_ClearFlags", + "original_fully_qualified_name": "ClearFlags", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiNextItemData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiNextItemData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiNextItemData", + "comments": { + "attached": "// Also cleared manually by ItemAdd()!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1355 + } + }, + { + "name": "ImGuiKeyRoutingTable_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiKeyRoutingTable*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiKeyRoutingTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiKeyRoutingTable", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1578 + } + }, + { + "name": "ImGuiListClipperRange_FromIndices", + "original_fully_qualified_name": "ImGuiListClipperRange::FromIndices", + "return_type": { + "declaration": "ImGuiListClipperRange", + "description": { + "kind": "User", + "name": "ImGuiListClipperRange" + } + }, + "arguments": [ + { + "name": "min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": true, + "original_class": "ImGuiListClipperRange", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1648 + } + }, + { + "name": "ImGuiListClipperRange_FromPositions", + "original_fully_qualified_name": "ImGuiListClipperRange::FromPositions", + "return_type": { + "declaration": "ImGuiListClipperRange", + "description": { + "kind": "User", + "name": "ImGuiListClipperRange" + } + }, + "arguments": [ + { + "name": "y1", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "y2", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "off_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "off_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": true, + "original_class": "ImGuiListClipperRange", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1649 + } + }, + { + "name": "ImGuiListClipperData_Reset", + "original_fully_qualified_name": "Reset", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipperData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipperData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "clipper", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipperData", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1662 + } + }, + { + "name": "ImGuiNavItemData_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiNavItemData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiNavItemData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiNavItemData", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1752 + } + }, + { + "name": "ImGuiTypingSelectState_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTypingSelectState*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTypingSelectState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTypingSelectState", + "comments": { + "attached": "// We preserve remaining data for easier debugging" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1796 + } + }, + { + "name": "ImGuiMultiSelectTempData_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiMultiSelectTempData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectTempData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiMultiSelectTempData", + "comments": { + "attached": "// Zero-clear except IO as we preserve IO.Requests[] buffer allocation." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1911 + } + }, + { + "name": "ImGuiMultiSelectTempData_ClearIO", + "original_fully_qualified_name": "ClearIO", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiMultiSelectTempData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectTempData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiMultiSelectTempData", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 1912 + } + }, + { + "name": "ImGuiDockNode_IsRootNode", + "original_fully_qualified_name": "IsRootNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2036 + } + }, + { + "name": "ImGuiDockNode_IsDockSpace", + "original_fully_qualified_name": "IsDockSpace", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2037 + } + }, + { + "name": "ImGuiDockNode_IsFloatingNode", + "original_fully_qualified_name": "IsFloatingNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2038 + } + }, + { + "name": "ImGuiDockNode_IsCentralNode", + "original_fully_qualified_name": "IsCentralNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2039 + } + }, + { + "name": "ImGuiDockNode_IsHiddenTabBar", + "original_fully_qualified_name": "IsHiddenTabBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "comments": { + "attached": "// Hidden tab bar can be shown back by clicking the small triangle" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2040 + } + }, + { + "name": "ImGuiDockNode_IsNoTabBar", + "original_fully_qualified_name": "IsNoTabBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "comments": { + "attached": "// Never show a tab bar" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2041 + } + }, + { + "name": "ImGuiDockNode_IsSplitNode", + "original_fully_qualified_name": "IsSplitNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2042 + } + }, + { + "name": "ImGuiDockNode_IsLeafNode", + "original_fully_qualified_name": "IsLeafNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2043 + } + }, + { + "name": "ImGuiDockNode_IsEmpty", + "original_fully_qualified_name": "IsEmpty", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2044 + } + }, + { + "name": "ImGuiDockNode_Rect", + "original_fully_qualified_name": "Rect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2045 + } + }, + { + "name": "ImGuiDockNode_SetLocalFlags", + "original_fully_qualified_name": "SetLocalFlags", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2047 + } + }, + { + "name": "ImGuiDockNode_UpdateMergedFlags", + "original_fully_qualified_name": "UpdateMergedFlags", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiDockNode", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_HAS_DOCK" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2048 + } + }, + { + "name": "ImGuiViewportP_ClearRequestFlags", + "original_fully_qualified_name": "ClearRequestFlags", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewportP", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2123 + } + }, + { + "name": "ImGuiViewportP_CalcWorkRectPos", + "original_fully_qualified_name": "CalcWorkRectPos", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiViewportP*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "inset_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewportP", + "comments": { + "preceding": [ + "// Calculate work rect pos/size given a set of offset (we have 1 pair of offset for rect locked from last frame data, and 1 pair for currently building rect)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2126 + } + }, + { + "name": "ImGuiViewportP_CalcWorkRectSize", + "original_fully_qualified_name": "CalcWorkRectSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiViewportP*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "inset_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "inset_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewportP", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2127 + } + }, + { + "name": "ImGuiViewportP_UpdateWorkRect", + "original_fully_qualified_name": "UpdateWorkRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewportP", + "comments": { + "attached": "// Update public fields" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2128 + } + }, + { + "name": "ImGuiViewportP_GetMainRect", + "original_fully_qualified_name": "GetMainRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiViewportP*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewportP", + "comments": { + "preceding": [ + "// Helpers to retrieve ImRect (we don't need to store BuildWorkRect as every access tend to change it, hence the code asymmetry)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2131 + } + }, + { + "name": "ImGuiViewportP_GetWorkRect", + "original_fully_qualified_name": "GetWorkRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiViewportP*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewportP", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2132 + } + }, + { + "name": "ImGuiViewportP_GetBuildWorkRect", + "original_fully_qualified_name": "GetBuildWorkRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiViewportP*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewportP", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2133 + } + }, + { + "name": "ImGuiWindowSettings_GetName", + "original_fully_qualified_name": "GetName", + "return_type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiWindowSettings*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindowSettings" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindowSettings", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2159 + } + }, + { + "name": "ImGuiWindow_GetIDStr", + "original_fully_qualified_name": "GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "comments": { + "attached": "// Implied str_end = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2925 + } + }, + { + "name": "ImGuiWindow_GetIDStrEx", + "original_fully_qualified_name": "GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2925 + } + }, + { + "name": "ImGuiWindow_GetID", + "original_fully_qualified_name": "GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "ptr", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2926 + } + }, + { + "name": "ImGuiWindow_GetIDInt", + "original_fully_qualified_name": "GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2927 + } + }, + { + "name": "ImGuiWindow_GetIDFromPos", + "original_fully_qualified_name": "GetIDFromPos", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p_abs", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2928 + } + }, + { + "name": "ImGuiWindow_GetIDFromRectangle", + "original_fully_qualified_name": "GetIDFromRectangle", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r_abs", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2929 + } + }, + { + "name": "ImGuiWindow_Rect", + "original_fully_qualified_name": "Rect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "comments": { + "preceding": [ + "// We don't use g.FontSize because the window may be != g.CurrentWindow." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2932 + } + }, + { + "name": "ImGuiWindow_TitleBarRect", + "original_fully_qualified_name": "TitleBarRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2933 + } + }, + { + "name": "ImGuiWindow_MenuBarRect", + "original_fully_qualified_name": "MenuBarRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiWindow*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiWindow", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiWindow", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 2934 + } + }, + { + "name": "ImGuiTableSettings_GetColumnSettings", + "original_fully_qualified_name": "GetColumnSettings", + "return_type": { + "declaration": "ImGuiTableColumnSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumnSettings" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTableSettings*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTableSettings" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTableSettings", + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3310 + } + }, + { + "name": "ImGui_GetIOImGuiContextPtr", + "original_fully_qualified_name": "ImGui::GetIO", + "return_type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Windows", + "// We should always have a CurrentWindow in the stack (there is an implicit \"Debug\" window)", + "// If this ever crashes because g.CurrentWindow is NULL, it means that either:", + "// - ImGui::NewFrame() has never been called, which is illegal.", + "// - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3325 + } + }, + { + "name": "ImGui_GetPlatformIOImGuiContextPtr", + "original_fully_qualified_name": "ImGui::GetPlatformIO", + "return_type": { + "declaration": "ImGuiPlatformIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "User", + "name": "ImGuiPlatformIO" + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3326 + } + }, + { + "name": "ImGui_GetCurrentWindowRead", + "original_fully_qualified_name": "ImGui::GetCurrentWindowRead", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3327 + } + }, + { + "name": "ImGui_GetCurrentWindow", + "original_fully_qualified_name": "ImGui::GetCurrentWindow", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3328 + } + }, + { + "name": "ImGui_FindWindowByID", + "original_fully_qualified_name": "ImGui::FindWindowByID", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3329 + } + }, + { + "name": "ImGui_FindWindowByName", + "original_fully_qualified_name": "ImGui::FindWindowByName", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3330 + } + }, + { + "name": "ImGui_UpdateWindowParentAndRootLinks", + "original_fully_qualified_name": "ImGui::UpdateWindowParentAndRootLinks", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "parent_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3331 + } + }, + { + "name": "ImGui_UpdateWindowSkipRefresh", + "original_fully_qualified_name": "ImGui::UpdateWindowSkipRefresh", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3332 + } + }, + { + "name": "ImGui_CalcWindowNextAutoFitSize", + "original_fully_qualified_name": "ImGui::CalcWindowNextAutoFitSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3333 + } + }, + { + "name": "ImGui_IsWindowChildOf", + "original_fully_qualified_name": "ImGui::IsWindowChildOf", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "potential_parent", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_hierarchy", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dock_hierarchy", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3334 + } + }, + { + "name": "ImGui_IsWindowWithinBeginStackOf", + "original_fully_qualified_name": "ImGui::IsWindowWithinBeginStackOf", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "potential_parent", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3335 + } + }, + { + "name": "ImGui_IsWindowAbove", + "original_fully_qualified_name": "ImGui::IsWindowAbove", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "potential_above", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "potential_below", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3336 + } + }, + { + "name": "ImGui_IsWindowNavFocusable", + "original_fully_qualified_name": "ImGui::IsWindowNavFocusable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3337 + } + }, + { + "name": "ImGui_SetWindowPosImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::SetWindowPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3338 + } + }, + { + "name": "ImGui_SetWindowSizeImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::SetWindowSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3339 + } + }, + { + "name": "ImGui_SetWindowCollapsedImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::SetWindowCollapsed", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "collapsed", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3340 + } + }, + { + "name": "ImGui_SetWindowHitTestHole", + "original_fully_qualified_name": "ImGui::SetWindowHitTestHole", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3341 + } + }, + { + "name": "ImGui_SetWindowHiddenAndSkipItemsForCurrentFrame", + "original_fully_qualified_name": "ImGui::SetWindowHiddenAndSkipItemsForCurrentFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3342 + } + }, + { + "name": "ImGui_SetWindowParentWindowForFocusRoute", + "original_fully_qualified_name": "ImGui::SetWindowParentWindowForFocusRoute", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "parent_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// You may also use SetNextWindowClass()'s FocusRouteParentWindowId field." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3343 + } + }, + { + "name": "ImGui_WindowRectAbsToRel", + "original_fully_qualified_name": "ImGui::WindowRectAbsToRel", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3344 + } + }, + { + "name": "ImGui_WindowRectRelToAbs", + "original_fully_qualified_name": "ImGui::WindowRectRelToAbs", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3345 + } + }, + { + "name": "ImGui_WindowPosAbsToRel", + "original_fully_qualified_name": "ImGui::WindowPosAbsToRel", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3346 + } + }, + { + "name": "ImGui_WindowPosRelToAbs", + "original_fully_qualified_name": "ImGui::WindowPosRelToAbs", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3347 + } + }, + { + "name": "ImGui_FocusWindow", + "original_fully_qualified_name": "ImGui::FocusWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiFocusRequestFlags", + "description": { + "kind": "User", + "name": "ImGuiFocusRequestFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Windows: Display Order and Focus Order" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3350 + } + }, + { + "name": "ImGui_FocusTopMostWindowUnderOne", + "original_fully_qualified_name": "ImGui::FocusTopMostWindowUnderOne", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "under_this_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "ignore_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "filter_viewport", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiFocusRequestFlags", + "description": { + "kind": "User", + "name": "ImGuiFocusRequestFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3351 + } + }, + { + "name": "ImGui_BringWindowToFocusFront", + "original_fully_qualified_name": "ImGui::BringWindowToFocusFront", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3352 + } + }, + { + "name": "ImGui_BringWindowToDisplayFront", + "original_fully_qualified_name": "ImGui::BringWindowToDisplayFront", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3353 + } + }, + { + "name": "ImGui_BringWindowToDisplayBack", + "original_fully_qualified_name": "ImGui::BringWindowToDisplayBack", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3354 + } + }, + { + "name": "ImGui_BringWindowToDisplayBehind", + "original_fully_qualified_name": "ImGui::BringWindowToDisplayBehind", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "above_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3355 + } + }, + { + "name": "ImGui_FindWindowDisplayIndex", + "original_fully_qualified_name": "ImGui::FindWindowDisplayIndex", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3356 + } + }, + { + "name": "ImGui_FindBottomMostVisibleWindowWithinBeginStack", + "original_fully_qualified_name": "ImGui::FindBottomMostVisibleWindowWithinBeginStack", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3357 + } + }, + { + "name": "ImGui_SetNextWindowRefreshPolicy", + "original_fully_qualified_name": "ImGui::SetNextWindowRefreshPolicy", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiWindowRefreshFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowRefreshFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Windows: Idle, Refresh Policies [EXPERIMENTAL]" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3360 + } + }, + { + "name": "ImGui_RegisterUserTexture", + "original_fully_qualified_name": "ImGui::RegisterUserTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Fonts, drawing" + ], + "attached": "// Register external texture. EXPERIMENTAL: DO NOT USE YET." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3363 + } + }, + { + "name": "ImGui_UnregisterUserTexture", + "original_fully_qualified_name": "ImGui::UnregisterUserTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3364 + } + }, + { + "name": "ImGui_RegisterFontAtlas", + "original_fully_qualified_name": "ImGui::RegisterFontAtlas", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3365 + } + }, + { + "name": "ImGui_UnregisterFontAtlas", + "original_fully_qualified_name": "ImGui::UnregisterFontAtlas", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3366 + } + }, + { + "name": "ImGui_SetCurrentFont", + "original_fully_qualified_name": "ImGui::SetCurrentFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size_before_scaling", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size_after_scaling", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3367 + } + }, + { + "name": "ImGui_UpdateCurrentFontSize", + "original_fully_qualified_name": "ImGui::UpdateCurrentFontSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "restore_font_size_after_scaling", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3368 + } + }, + { + "name": "ImGui_SetFontRasterizerDensity", + "original_fully_qualified_name": "ImGui::SetFontRasterizerDensity", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "rasterizer_density", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3369 + } + }, + { + "name": "ImGui_GetFontRasterizerDensity", + "original_fully_qualified_name": "ImGui::GetFontRasterizerDensity", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3370 + } + }, + { + "name": "ImGui_GetRoundedFontSize", + "original_fully_qualified_name": "ImGui::GetRoundedFontSize", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3371 + } + }, + { + "name": "ImGui_GetDefaultFont", + "original_fully_qualified_name": "ImGui::GetDefaultFont", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3372 + } + }, + { + "name": "ImGui_PushPasswordFont", + "original_fully_qualified_name": "ImGui::PushPasswordFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3373 + } + }, + { + "name": "ImGui_PopPasswordFont", + "original_fully_qualified_name": "ImGui::PopPasswordFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3374 + } + }, + { + "name": "ImGui_GetForegroundDrawListImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::GetForegroundDrawList", + "return_type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3375 + } + }, + { + "name": "ImGui_AddDrawListToDrawDataEx", + "original_fully_qualified_name": "ImGui::AddDrawListToDrawDataEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_data", + "type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_list", + "type": { + "declaration": "ImVector_ImDrawListPtr*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_ImDrawListPtr" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3376 + } + }, + { + "name": "ImGui_Initialize", + "original_fully_qualified_name": "ImGui::Initialize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Init" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3379 + } + }, + { + "name": "ImGui_Shutdown", + "original_fully_qualified_name": "ImGui::Shutdown", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3380 + } + }, + { + "name": "ImGui_UpdateInputEvents", + "original_fully_qualified_name": "ImGui::UpdateInputEvents", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "trickle_fast_inputs", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// NewFrame" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3383 + } + }, + { + "name": "ImGui_UpdateHoveredWindowAndCaptureFlags", + "original_fully_qualified_name": "ImGui::UpdateHoveredWindowAndCaptureFlags", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "mouse_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3384 + } + }, + { + "name": "ImGui_FindHoveredWindowEx", + "original_fully_qualified_name": "ImGui::FindHoveredWindowEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "find_first_and_in_any_viewport", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_hovered_window", + "type": { + "declaration": "ImGuiWindow**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_hovered_window_under_moving_window", + "type": { + "declaration": "ImGuiWindow**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3385 + } + }, + { + "name": "ImGui_StartMouseMovingWindow", + "original_fully_qualified_name": "ImGui::StartMouseMovingWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3386 + } + }, + { + "name": "ImGui_StartMouseMovingWindowOrNode", + "original_fully_qualified_name": "ImGui::StartMouseMovingWindowOrNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "undock", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3387 + } + }, + { + "name": "ImGui_StopMouseMovingWindow", + "original_fully_qualified_name": "ImGui::StopMouseMovingWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3388 + } + }, + { + "name": "ImGui_UpdateMouseMovingWindowNewFrame", + "original_fully_qualified_name": "ImGui::UpdateMouseMovingWindowNewFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3389 + } + }, + { + "name": "ImGui_UpdateMouseMovingWindowEndFrame", + "original_fully_qualified_name": "ImGui::UpdateMouseMovingWindowEndFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3390 + } + }, + { + "name": "ImGui_AddContextHook", + "original_fully_qualified_name": "ImGui::AddContextHook", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "context", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hook", + "type": { + "declaration": "const ImGuiContextHook*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContextHook", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Generic context hooks" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3393 + } + }, + { + "name": "ImGui_RemoveContextHook", + "original_fully_qualified_name": "ImGui::RemoveContextHook", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "context", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hook_to_remove", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3394 + } + }, + { + "name": "ImGui_CallContextHooks", + "original_fully_qualified_name": "ImGui::CallContextHooks", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "context", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "type", + "type": { + "declaration": "ImGuiContextHookType", + "description": { + "kind": "User", + "name": "ImGuiContextHookType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3395 + } + }, + { + "name": "ImGui_TranslateWindowsInViewport", + "original_fully_qualified_name": "ImGui::TranslateWindowsInViewport", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "new_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "new_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Viewports" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3398 + } + }, + { + "name": "ImGui_ScaleWindowsInViewport", + "original_fully_qualified_name": "ImGui::ScaleWindowsInViewport", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scale", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3399 + } + }, + { + "name": "ImGui_DestroyPlatformWindow", + "original_fully_qualified_name": "ImGui::DestroyPlatformWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3400 + } + }, + { + "name": "ImGui_SetWindowViewport", + "original_fully_qualified_name": "ImGui::SetWindowViewport", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3401 + } + }, + { + "name": "ImGui_SetCurrentViewport", + "original_fully_qualified_name": "ImGui::SetCurrentViewport", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3402 + } + }, + { + "name": "ImGui_GetViewportPlatformMonitor", + "original_fully_qualified_name": "ImGui::GetViewportPlatformMonitor", + "return_type": { + "declaration": "const ImGuiPlatformMonitor*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPlatformMonitor", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3403 + } + }, + { + "name": "ImGui_FindHoveredViewportFromPlatformWindowStack", + "original_fully_qualified_name": "ImGui::FindHoveredViewportFromPlatformWindowStack", + "return_type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "arguments": [ + { + "name": "mouse_platform_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3404 + } + }, + { + "name": "ImGui_MarkIniSettingsDirty", + "original_fully_qualified_name": "ImGui::MarkIniSettingsDirty", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Settings" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3407 + } + }, + { + "name": "ImGui_MarkIniSettingsDirtyImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::MarkIniSettingsDirty", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3408 + } + }, + { + "name": "ImGui_ClearIniSettings", + "original_fully_qualified_name": "ImGui::ClearIniSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3409 + } + }, + { + "name": "ImGui_AddSettingsHandler", + "original_fully_qualified_name": "ImGui::AddSettingsHandler", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "handler", + "type": { + "declaration": "const ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3410 + } + }, + { + "name": "ImGui_RemoveSettingsHandler", + "original_fully_qualified_name": "ImGui::RemoveSettingsHandler", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "type_name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3411 + } + }, + { + "name": "ImGui_FindSettingsHandler", + "original_fully_qualified_name": "ImGui::FindSettingsHandler", + "return_type": { + "declaration": "ImGuiSettingsHandler*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSettingsHandler" + } + } + }, + "arguments": [ + { + "name": "type_name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3412 + } + }, + { + "name": "ImGui_CreateNewWindowSettings", + "original_fully_qualified_name": "ImGui::CreateNewWindowSettings", + "return_type": { + "declaration": "ImGuiWindowSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowSettings" + } + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Settings - Windows" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3415 + } + }, + { + "name": "ImGui_FindWindowSettingsByID", + "original_fully_qualified_name": "ImGui::FindWindowSettingsByID", + "return_type": { + "declaration": "ImGuiWindowSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowSettings" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3416 + } + }, + { + "name": "ImGui_FindWindowSettingsByWindow", + "original_fully_qualified_name": "ImGui::FindWindowSettingsByWindow", + "return_type": { + "declaration": "ImGuiWindowSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowSettings" + } + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3417 + } + }, + { + "name": "ImGui_ClearWindowSettings", + "original_fully_qualified_name": "ImGui::ClearWindowSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3418 + } + }, + { + "name": "ImGui_LocalizeRegisterEntries", + "original_fully_qualified_name": "ImGui::LocalizeRegisterEntries", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "entries", + "type": { + "declaration": "const ImGuiLocEntry*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiLocEntry", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Localization" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3421 + } + }, + { + "name": "ImGui_LocalizeGetMsg", + "original_fully_qualified_name": "ImGui::LocalizeGetMsg", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiLocKey", + "description": { + "kind": "User", + "name": "ImGuiLocKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3422 + } + }, + { + "name": "ImGui_SetScrollXImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::SetScrollX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scroll_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Scrolling" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3425 + } + }, + { + "name": "ImGui_SetScrollYImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::SetScrollY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scroll_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3426 + } + }, + { + "name": "ImGui_SetScrollFromPosXImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::SetScrollFromPosX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "local_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "center_x_ratio", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3427 + } + }, + { + "name": "ImGui_SetScrollFromPosYImGuiWindowPtr", + "original_fully_qualified_name": "ImGui::SetScrollFromPosY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "local_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "center_y_ratio", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3428 + } + }, + { + "name": "ImGui_ScrollToItem", + "original_fully_qualified_name": "ImGui::ScrollToItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiScrollFlags", + "description": { + "kind": "User", + "name": "ImGuiScrollFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Early work-in-progress API (ScrollToItem() will become public)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3431 + } + }, + { + "name": "ImGui_ScrollToRect", + "original_fully_qualified_name": "ImGui::ScrollToRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiScrollFlags", + "description": { + "kind": "User", + "name": "ImGuiScrollFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3432 + } + }, + { + "name": "ImGui_ScrollToRectEx", + "original_fully_qualified_name": "ImGui::ScrollToRectEx", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiScrollFlags", + "description": { + "kind": "User", + "name": "ImGuiScrollFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3433 + } + }, + { + "name": "ImGui_ScrollToBringRectIntoView", + "original_fully_qualified_name": "ImGui::ScrollToBringRectIntoView", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "//#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3435 + } + }, + { + "name": "ImGui_GetItemStatusFlags", + "original_fully_qualified_name": "ImGui::GetItemStatusFlags", + "return_type": { + "declaration": "ImGuiItemStatusFlags", + "description": { + "kind": "User", + "name": "ImGuiItemStatusFlags" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Basic Accessors" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3439 + } + }, + { + "name": "ImGui_GetItemFlags", + "original_fully_qualified_name": "ImGui::GetItemFlags", + "return_type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3440 + } + }, + { + "name": "ImGui_GetActiveID", + "original_fully_qualified_name": "ImGui::GetActiveID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3441 + } + }, + { + "name": "ImGui_GetFocusID", + "original_fully_qualified_name": "ImGui::GetFocusID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3442 + } + }, + { + "name": "ImGui_SetActiveID", + "original_fully_qualified_name": "ImGui::SetActiveID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3443 + } + }, + { + "name": "ImGui_SetFocusID", + "original_fully_qualified_name": "ImGui::SetFocusID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3444 + } + }, + { + "name": "ImGui_ClearActiveID", + "original_fully_qualified_name": "ImGui::ClearActiveID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3445 + } + }, + { + "name": "ImGui_GetHoveredID", + "original_fully_qualified_name": "ImGui::GetHoveredID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3446 + } + }, + { + "name": "ImGui_SetHoveredID", + "original_fully_qualified_name": "ImGui::SetHoveredID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3447 + } + }, + { + "name": "ImGui_KeepAliveID", + "original_fully_qualified_name": "ImGui::KeepAliveID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3448 + } + }, + { + "name": "ImGui_MarkItemEdited", + "original_fully_qualified_name": "ImGui::MarkItemEdited", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Mark data associated to given item as \"edited\", used by IsItemDeactivatedAfterEdit() function." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3449 + } + }, + { + "name": "ImGui_PushOverrideID", + "original_fully_qualified_name": "ImGui::PushOverrideID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Push given value as-is at the top of the ID stack (whereas PushID combines old and new hashes)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3450 + } + }, + { + "name": "ImGui_GetIDWithSeedStr", + "original_fully_qualified_name": "ImGui::GetIDWithSeed", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "str_id_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str_id_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "seed", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3451 + } + }, + { + "name": "ImGui_GetIDWithSeed", + "original_fully_qualified_name": "ImGui::GetIDWithSeed", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "seed", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3452 + } + }, + { + "name": "ImGui_ItemSize", + "original_fully_qualified_name": "ImGui::ItemSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Basic Helpers for widget code" + ], + "attached": "// Implied text_baseline_y = -1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3455 + } + }, + { + "name": "ImGui_ItemSizeEx", + "original_fully_qualified_name": "ImGui::ItemSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_baseline_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3455 + } + }, + { + "name": "ImGui_ItemSizeImRect", + "original_fully_qualified_name": "ImGui::ItemSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied text_baseline_y = -1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3456 + } + }, + { + "name": "ImGui_ItemSizeImRectEx", + "original_fully_qualified_name": "ImGui::ItemSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_baseline_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// FIXME: This is a misleading API since we expect CursorPos to be bb.Min." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3456 + } + }, + { + "name": "ImGui_ItemAdd", + "original_fully_qualified_name": "ImGui::ItemAdd", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied nav_bb = NULL, extra_flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3457 + } + }, + { + "name": "ImGui_ItemAddEx", + "original_fully_qualified_name": "ImGui::ItemAdd", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "nav_bb", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "extra_flags", + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3457 + } + }, + { + "name": "ImGui_ItemHoverable", + "original_fully_qualified_name": "ImGui::ItemHoverable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "item_flags", + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3458 + } + }, + { + "name": "ImGui_IsWindowContentHoverable", + "original_fully_qualified_name": "ImGui::IsWindowContentHoverable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiHoveredFlags", + "description": { + "kind": "User", + "name": "ImGuiHoveredFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3459 + } + }, + { + "name": "ImGui_IsClippedEx", + "original_fully_qualified_name": "ImGui::IsClippedEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3460 + } + }, + { + "name": "ImGui_SetLastItemData", + "original_fully_qualified_name": "ImGui::SetLastItemData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "item_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "item_flags", + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "status_flags", + "type": { + "declaration": "ImGuiItemStatusFlags", + "description": { + "kind": "User", + "name": "ImGuiItemStatusFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "item_rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3461 + } + }, + { + "name": "ImGui_CalcItemSize", + "original_fully_qualified_name": "ImGui::CalcItemSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_w", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_h", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3462 + } + }, + { + "name": "ImGui_CalcWrapWidthForPos", + "original_fully_qualified_name": "ImGui::CalcWrapWidthForPos", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wrap_pos_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3463 + } + }, + { + "name": "ImGui_PushMultiItemsWidths", + "original_fully_qualified_name": "ImGui::PushMultiItemsWidths", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "components", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "width_full", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3464 + } + }, + { + "name": "ImGui_ShrinkWidths", + "original_fully_qualified_name": "ImGui::ShrinkWidths", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "items", + "type": { + "declaration": "ImGuiShrinkWidthItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiShrinkWidthItem" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "width_excess", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "width_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3465 + } + }, + { + "name": "ImGui_GetStyleVarInfo", + "original_fully_qualified_name": "ImGui::GetStyleVarInfo", + "return_type": { + "declaration": "const ImGuiStyleVarInfo*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStyleVarInfo", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiStyleVar", + "description": { + "kind": "User", + "name": "ImGuiStyleVar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Parameter stacks (shared)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3468 + } + }, + { + "name": "ImGui_BeginDisabledOverrideReenable", + "original_fully_qualified_name": "ImGui::BeginDisabledOverrideReenable", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3469 + } + }, + { + "name": "ImGui_EndDisabledOverrideReenable", + "original_fully_qualified_name": "ImGui::EndDisabledOverrideReenable", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3470 + } + }, + { + "name": "ImGui_LogBegin", + "original_fully_qualified_name": "ImGui::LogBegin", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiLogFlags", + "description": { + "kind": "User", + "name": "ImGuiLogFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "auto_open_depth", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Logging/Capture" + ], + "attached": "// -> BeginCapture() when we design v2 api, for now stay under the radar by using the old name." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3473 + } + }, + { + "name": "ImGui_LogToBuffer", + "original_fully_qualified_name": "ImGui::LogToBuffer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied auto_open_depth = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3474 + } + }, + { + "name": "ImGui_LogToBufferEx", + "original_fully_qualified_name": "ImGui::LogToBuffer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "auto_open_depth", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Start logging/capturing to internal buffer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3474 + } + }, + { + "name": "ImGui_LogRenderedText", + "original_fully_qualified_name": "ImGui::LogRenderedText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ref_pos", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied text_end = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3475 + } + }, + { + "name": "ImGui_LogRenderedTextEx", + "original_fully_qualified_name": "ImGui::LogRenderedText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ref_pos", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3475 + } + }, + { + "name": "ImGui_LogSetNextTextDecoration", + "original_fully_qualified_name": "ImGui::LogSetNextTextDecoration", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "prefix", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "suffix", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3476 + } + }, + { + "name": "ImGui_BeginChildEx", + "original_fully_qualified_name": "ImGui::BeginChildEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_arg", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "child_flags", + "type": { + "declaration": "ImGuiChildFlags", + "description": { + "kind": "User", + "name": "ImGuiChildFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Childs" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3479 + } + }, + { + "name": "ImGui_BeginPopupEx", + "original_fully_qualified_name": "ImGui::BeginPopupEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "extra_window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Popups, Modals" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3482 + } + }, + { + "name": "ImGui_BeginPopupMenuEx", + "original_fully_qualified_name": "ImGui::BeginPopupMenuEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "extra_window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3483 + } + }, + { + "name": "ImGui_OpenPopupEx", + "original_fully_qualified_name": "ImGui::OpenPopupEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied popup_flags = ImGuiPopupFlags_None" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3484 + } + }, + { + "name": "ImGui_OpenPopupExEx", + "original_fully_qualified_name": "ImGui::OpenPopupEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImGuiPopupFlags_None", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3484 + } + }, + { + "name": "ImGui_ClosePopupToLevel", + "original_fully_qualified_name": "ImGui::ClosePopupToLevel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "remaining", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "restore_focus_to_window_under_popup", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3485 + } + }, + { + "name": "ImGui_ClosePopupsOverWindow", + "original_fully_qualified_name": "ImGui::ClosePopupsOverWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ref_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "restore_focus_to_window_under_popup", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3486 + } + }, + { + "name": "ImGui_ClosePopupsExceptModals", + "original_fully_qualified_name": "ImGui::ClosePopupsExceptModals", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3487 + } + }, + { + "name": "ImGui_IsPopupOpenID", + "original_fully_qualified_name": "ImGui::IsPopupOpen", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3488 + } + }, + { + "name": "ImGui_GetPopupAllowedExtentRect", + "original_fully_qualified_name": "ImGui::GetPopupAllowedExtentRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3489 + } + }, + { + "name": "ImGui_GetTopMostPopupModal", + "original_fully_qualified_name": "ImGui::GetTopMostPopupModal", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3490 + } + }, + { + "name": "ImGui_GetTopMostAndVisiblePopupModal", + "original_fully_qualified_name": "ImGui::GetTopMostAndVisiblePopupModal", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3491 + } + }, + { + "name": "ImGui_FindBlockingModal", + "original_fully_qualified_name": "ImGui::FindBlockingModal", + "return_type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3492 + } + }, + { + "name": "ImGui_FindBestWindowPosForPopup", + "original_fully_qualified_name": "ImGui::FindBestWindowPosForPopup", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3493 + } + }, + { + "name": "ImGui_FindBestWindowPosForPopupEx", + "original_fully_qualified_name": "ImGui::FindBestWindowPosForPopupEx", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "ref_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "last_dir", + "type": { + "declaration": "ImGuiDir*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDir" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r_outer", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r_avoid", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "policy", + "type": { + "declaration": "ImGuiPopupPositionPolicy", + "description": { + "kind": "User", + "name": "ImGuiPopupPositionPolicy" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3494 + } + }, + { + "name": "ImGui_BeginTooltipEx", + "original_fully_qualified_name": "ImGui::BeginTooltipEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "tooltip_flags", + "type": { + "declaration": "ImGuiTooltipFlags", + "description": { + "kind": "User", + "name": "ImGuiTooltipFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "extra_window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tooltips" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3497 + } + }, + { + "name": "ImGui_BeginTooltipHidden", + "original_fully_qualified_name": "ImGui::BeginTooltipHidden", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3498 + } + }, + { + "name": "ImGui_BeginViewportSideBar", + "original_fully_qualified_name": "ImGui::BeginViewportSideBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Menus" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3501 + } + }, + { + "name": "ImGui_BeginMenuWithIcon", + "original_fully_qualified_name": "ImGui::BeginMenuEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "icon", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied enabled = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3502 + } + }, + { + "name": "ImGui_BeginMenuWithIconEx", + "original_fully_qualified_name": "ImGui::BeginMenuEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "icon", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "enabled", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3502 + } + }, + { + "name": "ImGui_MenuItemWithIcon", + "original_fully_qualified_name": "ImGui::MenuItemEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "icon", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied shortcut = NULL, selected = false, enabled = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3503 + } + }, + { + "name": "ImGui_MenuItemWithIconEx", + "original_fully_qualified_name": "ImGui::MenuItemEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "icon", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "shortcut", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "selected", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + }, + { + "name": "enabled", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3503 + } + }, + { + "name": "ImGui_BeginComboPopup", + "original_fully_qualified_name": "ImGui::BeginComboPopup", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "popup_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiComboFlags", + "description": { + "kind": "User", + "name": "ImGuiComboFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Combos" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3506 + } + }, + { + "name": "ImGui_BeginComboPreview", + "original_fully_qualified_name": "ImGui::BeginComboPreview", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3507 + } + }, + { + "name": "ImGui_EndComboPreview", + "original_fully_qualified_name": "ImGui::EndComboPreview", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3508 + } + }, + { + "name": "ImGui_NavInitWindow", + "original_fully_qualified_name": "ImGui::NavInitWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "force_reinit", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Keyboard/Gamepad Navigation" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3511 + } + }, + { + "name": "ImGui_NavInitRequestApplyResult", + "original_fully_qualified_name": "ImGui::NavInitRequestApplyResult", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3512 + } + }, + { + "name": "ImGui_NavMoveRequestButNoResultYet", + "original_fully_qualified_name": "ImGui::NavMoveRequestButNoResultYet", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3513 + } + }, + { + "name": "ImGui_NavMoveRequestSubmit", + "original_fully_qualified_name": "ImGui::NavMoveRequestSubmit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "move_dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clip_dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "move_flags", + "type": { + "declaration": "ImGuiNavMoveFlags", + "description": { + "kind": "User", + "name": "ImGuiNavMoveFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scroll_flags", + "type": { + "declaration": "ImGuiScrollFlags", + "description": { + "kind": "User", + "name": "ImGuiScrollFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3514 + } + }, + { + "name": "ImGui_NavMoveRequestForward", + "original_fully_qualified_name": "ImGui::NavMoveRequestForward", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "move_dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clip_dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "move_flags", + "type": { + "declaration": "ImGuiNavMoveFlags", + "description": { + "kind": "User", + "name": "ImGuiNavMoveFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scroll_flags", + "type": { + "declaration": "ImGuiScrollFlags", + "description": { + "kind": "User", + "name": "ImGuiScrollFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3515 + } + }, + { + "name": "ImGui_NavMoveRequestResolveWithLastItem", + "original_fully_qualified_name": "ImGui::NavMoveRequestResolveWithLastItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "result", + "type": { + "declaration": "ImGuiNavItemData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiNavItemData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3516 + } + }, + { + "name": "ImGui_NavMoveRequestResolveWithPastTreeNode", + "original_fully_qualified_name": "ImGui::NavMoveRequestResolveWithPastTreeNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "result", + "type": { + "declaration": "ImGuiNavItemData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiNavItemData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tree_node_data", + "type": { + "declaration": "const ImGuiTreeNodeStackData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTreeNodeStackData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3517 + } + }, + { + "name": "ImGui_NavMoveRequestCancel", + "original_fully_qualified_name": "ImGui::NavMoveRequestCancel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3518 + } + }, + { + "name": "ImGui_NavMoveRequestApplyResult", + "original_fully_qualified_name": "ImGui::NavMoveRequestApplyResult", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3519 + } + }, + { + "name": "ImGui_NavMoveRequestTryWrapping", + "original_fully_qualified_name": "ImGui::NavMoveRequestTryWrapping", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "move_flags", + "type": { + "declaration": "ImGuiNavMoveFlags", + "description": { + "kind": "User", + "name": "ImGuiNavMoveFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3520 + } + }, + { + "name": "ImGui_NavHighlightActivated", + "original_fully_qualified_name": "ImGui::NavHighlightActivated", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3521 + } + }, + { + "name": "ImGui_NavClearPreferredPosForAxis", + "original_fully_qualified_name": "ImGui::NavClearPreferredPosForAxis", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3522 + } + }, + { + "name": "ImGui_SetNavCursorVisibleAfterMove", + "original_fully_qualified_name": "ImGui::SetNavCursorVisibleAfterMove", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3523 + } + }, + { + "name": "ImGui_NavUpdateCurrentWindowIsScrollPushableX", + "original_fully_qualified_name": "ImGui::NavUpdateCurrentWindowIsScrollPushableX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3524 + } + }, + { + "name": "ImGui_SetNavWindow", + "original_fully_qualified_name": "ImGui::SetNavWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3525 + } + }, + { + "name": "ImGui_SetNavID", + "original_fully_qualified_name": "ImGui::SetNavID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "nav_layer", + "type": { + "declaration": "ImGuiNavLayer", + "description": { + "kind": "User", + "name": "ImGuiNavLayer" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "focus_scope_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rect_rel", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3526 + } + }, + { + "name": "ImGui_SetNavFocusScope", + "original_fully_qualified_name": "ImGui::SetNavFocusScope", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "focus_scope_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3527 + } + }, + { + "name": "ImGui_FocusItem", + "original_fully_qualified_name": "ImGui::FocusItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Focus/Activation", + "// This should be part of a larger set of API: FocusItem(offset = -1), FocusItemByID(id), ActivateItem(offset = -1), ActivateItemByID(id) etc. which are", + "// much harder to design and implement than expected. I have a couple of private branches on this matter but it's not simple. For now implementing the easy ones." + ], + "attached": "// Focus last item (no selection/activation)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3532 + } + }, + { + "name": "ImGui_ActivateItemByID", + "original_fully_qualified_name": "ImGui::ActivateItemByID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Activate an item by ID (button, checkbox, tree node etc.). Activation is queued and processed on the next frame when the item is encountered again. Was called 'ActivateItem()' before 1.89.7." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3533 + } + }, + { + "name": "ImGui_IsNamedKey", + "original_fully_qualified_name": "ImGui::IsNamedKey", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Inputs", + "// FIXME: Eventually we should aim to move e.g. IsActiveIdUsingKey() into IsKeyXXX functions." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3537 + } + }, + { + "name": "ImGui_IsNamedKeyOrMod", + "original_fully_qualified_name": "ImGui::IsNamedKeyOrMod", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3538 + } + }, + { + "name": "ImGui_IsLegacyKey", + "original_fully_qualified_name": "ImGui::IsLegacyKey", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3539 + } + }, + { + "name": "ImGui_IsKeyboardKey", + "original_fully_qualified_name": "ImGui::IsKeyboardKey", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3540 + } + }, + { + "name": "ImGui_IsGamepadKey", + "original_fully_qualified_name": "ImGui::IsGamepadKey", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3541 + } + }, + { + "name": "ImGui_IsMouseKey", + "original_fully_qualified_name": "ImGui::IsMouseKey", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3542 + } + }, + { + "name": "ImGui_IsAliasKey", + "original_fully_qualified_name": "ImGui::IsAliasKey", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3543 + } + }, + { + "name": "ImGui_IsLRModKey", + "original_fully_qualified_name": "ImGui::IsLRModKey", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3544 + } + }, + { + "name": "ImGui_FixupKeyChord", + "original_fully_qualified_name": "ImGui::FixupKeyChord", + "return_type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3545 + } + }, + { + "name": "ImGui_ConvertSingleModFlagToKey", + "original_fully_qualified_name": "ImGui::ConvertSingleModFlagToKey", + "return_type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3546 + } + }, + { + "name": "ImGui_GetKeyDataImGuiContextPtr", + "original_fully_qualified_name": "ImGui::GetKeyData", + "return_type": { + "declaration": "ImGuiKeyData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyData" + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3555 + } + }, + { + "name": "ImGui_GetKeyData", + "original_fully_qualified_name": "ImGui::GetKeyData", + "return_type": { + "declaration": "ImGuiKeyData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyData" + } + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3556 + } + }, + { + "name": "ImGui_GetKeyChordName", + "original_fully_qualified_name": "ImGui::GetKeyChordName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3557 + } + }, + { + "name": "ImGui_MouseButtonToKey", + "original_fully_qualified_name": "ImGui::MouseButtonToKey", + "return_type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3558 + } + }, + { + "name": "ImGui_IsMouseDragPastThreshold", + "original_fully_qualified_name": "ImGui::IsMouseDragPastThreshold", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied lock_threshold = -1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3559 + } + }, + { + "name": "ImGui_IsMouseDragPastThresholdEx", + "original_fully_qualified_name": "ImGui::IsMouseDragPastThreshold", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "lock_threshold", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3559 + } + }, + { + "name": "ImGui_GetKeyMagnitude2d", + "original_fully_qualified_name": "ImGui::GetKeyMagnitude2d", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "key_left", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "key_right", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "key_up", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "key_down", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3560 + } + }, + { + "name": "ImGui_GetNavTweakPressedAmount", + "original_fully_qualified_name": "ImGui::GetNavTweakPressedAmount", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3561 + } + }, + { + "name": "ImGui_CalcTypematicRepeatAmount", + "original_fully_qualified_name": "ImGui::CalcTypematicRepeatAmount", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "t0", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "t1", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "repeat_delay", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "repeat_rate", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3562 + } + }, + { + "name": "ImGui_GetTypematicRepeatRate", + "original_fully_qualified_name": "ImGui::GetTypematicRepeatRate", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "repeat_delay", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "repeat_rate", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3563 + } + }, + { + "name": "ImGui_TeleportMousePos", + "original_fully_qualified_name": "ImGui::TeleportMousePos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3564 + } + }, + { + "name": "ImGui_SetActiveIdUsingAllKeyboardKeys", + "original_fully_qualified_name": "ImGui::SetActiveIdUsingAllKeyboardKeys", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3565 + } + }, + { + "name": "ImGui_IsActiveIdUsingNavDir", + "original_fully_qualified_name": "ImGui::IsActiveIdUsingNavDir", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3566 + } + }, + { + "name": "ImGui_GetKeyOwner", + "original_fully_qualified_name": "ImGui::GetKeyOwner", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// [EXPERIMENTAL] Low-Level: Key/Input Ownership", + "// - The idea is that instead of \"eating\" a given input, we can link to an owner id.", + "// - Ownership is most often claimed as a result of reacting to a press/down event (but occasionally may be claimed ahead).", + "// - Input queries can then read input by specifying ImGuiKeyOwner_Any (== 0), ImGuiKeyOwner_NoOwner (== -1) or a custom ID.", + "// - Legacy input queries (without specifying an owner or _Any or _None) are equivalent to using ImGuiKeyOwner_Any (== 0).", + "// - Input ownership is automatically released on the frame after a key is released. Therefore:", + "// - for ownership registration happening as a result of a down/press event, the SetKeyOwner() call may be done once (common case).", + "// - for ownership registration happening ahead of a down/press event, the SetKeyOwner() call needs to be made every frame (happens if e.g. claiming ownership on hover).", + "// - SetItemKeyOwner() is a shortcut for common simple case. A custom widget will probably want to call SetKeyOwner() multiple times directly based on its interaction state.", + "// - This is marked experimental because not all widgets are fully honoring the Set/Test idioms. We will need to move forward step by step.", + "// Please open a GitHub Issue to submit your usage scenario or if there's a use case you need solved." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3579 + } + }, + { + "name": "ImGui_SetKeyOwner", + "original_fully_qualified_name": "ImGui::SetKeyOwner", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3580 + } + }, + { + "name": "ImGui_SetKeyOwnersForKeyChord", + "original_fully_qualified_name": "ImGui::SetKeyOwnersForKeyChord", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3581 + } + }, + { + "name": "ImGui_SetItemKeyOwnerImGuiInputFlags", + "original_fully_qualified_name": "ImGui::SetItemKeyOwner", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Set key owner to last item if it is hovered or active. Equivalent to 'if (IsItemHovered() || IsItemActive()) { SetKeyOwner(key, GetItemID());'." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3582 + } + }, + { + "name": "ImGui_TestKeyOwner", + "original_fully_qualified_name": "ImGui::TestKeyOwner", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Test that key is either not owned, either owned by 'owner_id'" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3583 + } + }, + { + "name": "ImGui_GetKeyOwnerData", + "original_fully_qualified_name": "ImGui::GetKeyOwnerData", + "return_type": { + "declaration": "ImGuiKeyOwnerData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyOwnerData" + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3584 + } + }, + { + "name": "ImGui_IsKeyDownID", + "original_fully_qualified_name": "ImGui::IsKeyDown", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// [EXPERIMENTAL] High-Level: Input Access functions w/ support for Key/Input Ownership", + "// - Important: legacy IsKeyPressed(ImGuiKey, bool repeat=true) _DEFAULTS_ to repeat, new IsKeyPressed() requires _EXPLICIT_ ImGuiInputFlags_Repeat flag.", + "// - Expected to be later promoted to public API, the prototypes are designed to replace existing ones (since owner_id can default to Any == 0)", + "// - Specifying a value for 'ImGuiID owner' will test that EITHER the key is NOT owned (UNLESS locked), EITHER the key is owned by 'owner'.", + "// Legacy functions use ImGuiKeyOwner_Any meaning that they typically ignore ownership, unless a call to SetKeyOwner() explicitly used ImGuiInputFlags_LockThisFrame or ImGuiInputFlags_LockUntilRelease.", + "// - Binding generators may want to ignore those for now, or suffix them with Ex() until we decide if this gets moved into public API." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3592 + } + }, + { + "name": "ImGui_IsKeyPressedImGuiInputFlags", + "original_fully_qualified_name": "ImGui::IsKeyPressed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied owner_id = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3593 + } + }, + { + "name": "ImGui_IsKeyPressedImGuiInputFlagsEx", + "original_fully_qualified_name": "ImGui::IsKeyPressed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Important: when transitioning from old to new IsKeyPressed(): old API has \"bool repeat = true\", so would default to repeat. New API requiress explicit ImGuiInputFlags_Repeat." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3593 + } + }, + { + "name": "ImGui_IsKeyReleasedID", + "original_fully_qualified_name": "ImGui::IsKeyReleased", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3594 + } + }, + { + "name": "ImGui_IsKeyChordPressedImGuiInputFlags", + "original_fully_qualified_name": "ImGui::IsKeyChordPressed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied owner_id = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3595 + } + }, + { + "name": "ImGui_IsKeyChordPressedImGuiInputFlagsEx", + "original_fully_qualified_name": "ImGui::IsKeyChordPressed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3595 + } + }, + { + "name": "ImGui_IsMouseDownID", + "original_fully_qualified_name": "ImGui::IsMouseDown", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3596 + } + }, + { + "name": "ImGui_IsMouseClickedImGuiInputFlags", + "original_fully_qualified_name": "ImGui::IsMouseClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied owner_id = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3597 + } + }, + { + "name": "ImGui_IsMouseClickedImGuiInputFlagsEx", + "original_fully_qualified_name": "ImGui::IsMouseClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3597 + } + }, + { + "name": "ImGui_IsMouseReleasedID", + "original_fully_qualified_name": "ImGui::IsMouseReleased", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3598 + } + }, + { + "name": "ImGui_IsMouseDoubleClickedID", + "original_fully_qualified_name": "ImGui::IsMouseDoubleClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3599 + } + }, + { + "name": "ImGui_ShortcutID", + "original_fully_qualified_name": "ImGui::Shortcut", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Shortcut Testing & Routing", + "// - Set Shortcut() and SetNextItemShortcut() in imgui.h", + "// - When a policy (except for ImGuiInputFlags_RouteAlways *) is set, Shortcut() will register itself with SetShortcutRouting(),", + "// allowing the system to decide where to route the input among other route-aware calls.", + "// (* using ImGuiInputFlags_RouteAlways is roughly equivalent to calling IsKeyChordPressed(key) and bypassing route registration and check)", + "// - When using one of the routing option:", + "// - The default route is ImGuiInputFlags_RouteFocused (accept inputs if window is in focus stack. Deep-most focused window takes inputs. ActiveId takes inputs over deep-most focused window.)", + "// - Routes are requested given a chord (key + modifiers) and a routing policy.", + "// - Routes are resolved during NewFrame(): if keyboard modifiers are matching current ones: SetKeyOwner() is called + route is granted for the frame.", + "// - Each route may be granted to a single owner. When multiple requests are made we have policies to select the winning route (e.g. deep most window).", + "// - Multiple read sites may use the same owner id can all access the granted route.", + "// - When owner_id is 0 we use the current Focus Scope ID as a owner ID in order to identify our location.", + "// - You can chain two unrelated windows in the focus stack using SetWindowParentWindowForFocusRoute()", + "// e.g. if you have a tool window associated to a document, and you want document shortcuts to run when the tool is focused." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3615 + } + }, + { + "name": "ImGui_SetShortcutRouting", + "original_fully_qualified_name": "ImGui::SetShortcutRouting", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// owner_id needs to be explicit and cannot be 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3616 + } + }, + { + "name": "ImGui_TestShortcutRouting", + "original_fully_qualified_name": "ImGui::TestShortcutRouting", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "owner_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3617 + } + }, + { + "name": "ImGui_GetShortcutRoutingData", + "original_fully_qualified_name": "ImGui::GetShortcutRoutingData", + "return_type": { + "declaration": "ImGuiKeyRoutingData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyRoutingData" + } + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3618 + } + }, + { + "name": "ImGui_DockContextInitialize", + "original_fully_qualified_name": "ImGui::DockContextInitialize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Docking", + "// (some functions are only declared in imgui.cpp, see Docking section)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3622 + } + }, + { + "name": "ImGui_DockContextShutdown", + "original_fully_qualified_name": "ImGui::DockContextShutdown", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3623 + } + }, + { + "name": "ImGui_DockContextClearNodes", + "original_fully_qualified_name": "ImGui::DockContextClearNodes", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "root_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clear_settings_refs", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Use root_id==0 to clear all" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3624 + } + }, + { + "name": "ImGui_DockContextRebuildNodes", + "original_fully_qualified_name": "ImGui::DockContextRebuildNodes", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3625 + } + }, + { + "name": "ImGui_DockContextNewFrameUpdateUndocking", + "original_fully_qualified_name": "ImGui::DockContextNewFrameUpdateUndocking", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3626 + } + }, + { + "name": "ImGui_DockContextNewFrameUpdateDocking", + "original_fully_qualified_name": "ImGui::DockContextNewFrameUpdateDocking", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3627 + } + }, + { + "name": "ImGui_DockContextEndFrame", + "original_fully_qualified_name": "ImGui::DockContextEndFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3628 + } + }, + { + "name": "ImGui_DockContextGenNodeID", + "original_fully_qualified_name": "ImGui::DockContextGenNodeID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3629 + } + }, + { + "name": "ImGui_DockContextQueueDock", + "original_fully_qualified_name": "ImGui::DockContextQueueDock", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "target", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "target_node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "payload", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "split_dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "split_ratio", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "split_outer", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3630 + } + }, + { + "name": "ImGui_DockContextQueueUndockWindow", + "original_fully_qualified_name": "ImGui::DockContextQueueUndockWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3631 + } + }, + { + "name": "ImGui_DockContextQueueUndockNode", + "original_fully_qualified_name": "ImGui::DockContextQueueUndockNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3632 + } + }, + { + "name": "ImGui_DockContextProcessUndockWindow", + "original_fully_qualified_name": "ImGui::DockContextProcessUndockWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied clear_persistent_docking_ref = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3633 + } + }, + { + "name": "ImGui_DockContextProcessUndockWindowEx", + "original_fully_qualified_name": "ImGui::DockContextProcessUndockWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clear_persistent_docking_ref", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3633 + } + }, + { + "name": "ImGui_DockContextProcessUndockNode", + "original_fully_qualified_name": "ImGui::DockContextProcessUndockNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3634 + } + }, + { + "name": "ImGui_DockContextCalcDropPosForDocking", + "original_fully_qualified_name": "ImGui::DockContextCalcDropPosForDocking", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "target", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "target_node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "payload_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "payload_node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "split_dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "split_outer", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_pos", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3635 + } + }, + { + "name": "ImGui_DockContextFindNodeByID", + "original_fully_qualified_name": "ImGui::DockContextFindNodeByID", + "return_type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3636 + } + }, + { + "name": "ImGui_DockNodeWindowMenuHandler_Default", + "original_fully_qualified_name": "ImGui::DockNodeWindowMenuHandler_Default", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3637 + } + }, + { + "name": "ImGui_DockNodeBeginAmendTabBar", + "original_fully_qualified_name": "ImGui::DockNodeBeginAmendTabBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3638 + } + }, + { + "name": "ImGui_DockNodeEndAmendTabBar", + "original_fully_qualified_name": "ImGui::DockNodeEndAmendTabBar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3639 + } + }, + { + "name": "ImGui_DockNodeGetRootNode", + "original_fully_qualified_name": "ImGui::DockNodeGetRootNode", + "return_type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "arguments": [ + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3640 + } + }, + { + "name": "ImGui_DockNodeIsInHierarchyOf", + "original_fully_qualified_name": "ImGui::DockNodeIsInHierarchyOf", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "parent", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3641 + } + }, + { + "name": "ImGui_DockNodeGetDepth", + "original_fully_qualified_name": "ImGui::DockNodeGetDepth", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "node", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3642 + } + }, + { + "name": "ImGui_DockNodeGetWindowMenuButtonId", + "original_fully_qualified_name": "ImGui::DockNodeGetWindowMenuButtonId", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "node", + "type": { + "declaration": "const ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3643 + } + }, + { + "name": "ImGui_GetWindowDockNode", + "original_fully_qualified_name": "ImGui::GetWindowDockNode", + "return_type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3644 + } + }, + { + "name": "ImGui_GetWindowAlwaysWantOwnTabBar", + "original_fully_qualified_name": "ImGui::GetWindowAlwaysWantOwnTabBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3645 + } + }, + { + "name": "ImGui_BeginDocked", + "original_fully_qualified_name": "ImGui::BeginDocked", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3646 + } + }, + { + "name": "ImGui_BeginDockableDragDropSource", + "original_fully_qualified_name": "ImGui::BeginDockableDragDropSource", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3647 + } + }, + { + "name": "ImGui_BeginDockableDragDropTarget", + "original_fully_qualified_name": "ImGui::BeginDockableDragDropTarget", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3648 + } + }, + { + "name": "ImGui_SetWindowDock", + "original_fully_qualified_name": "ImGui::SetWindowDock", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dock_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3649 + } + }, + { + "name": "ImGui_DockBuilderDockWindow", + "original_fully_qualified_name": "ImGui::DockBuilderDockWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window_name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Docking - Builder function needs to be generally called before the node is used/submitted.", + "// - The DockBuilderXXX functions are designed to _eventually_ become a public API, but it is too early to expose it and guarantee stability.", + "// - Do not hold on ImGuiDockNode* pointers! They may be invalidated by any split/merge/remove operation and every frame.", + "// - To create a DockSpace() node, make sure to set the ImGuiDockNodeFlags_DockSpace flag when calling DockBuilderAddNode().", + "// You can create dockspace nodes (attached to a window) _or_ floating nodes (carry its own window) with this API.", + "// - DockBuilderSplitNode() create 2 child nodes within 1 node. The initial node becomes a parent node.", + "// - If you intend to split the node immediately after creation using DockBuilderSplitNode(), make sure", + "// to call DockBuilderSetNodeSize() beforehand. If you don't, the resulting split sizes may not be reliable.", + "// - Call DockBuilderFinish() after you are done." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3660 + } + }, + { + "name": "ImGui_DockBuilderGetNode", + "original_fully_qualified_name": "ImGui::DockBuilderGetNode", + "return_type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3661 + } + }, + { + "name": "ImGui_DockBuilderGetCentralNode", + "original_fully_qualified_name": "ImGui::DockBuilderGetCentralNode", + "return_type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3662 + } + }, + { + "name": "ImGui_DockBuilderAddNode", + "original_fully_qualified_name": "ImGui::DockBuilderAddNode", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied node_id = 0, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3663 + } + }, + { + "name": "ImGui_DockBuilderAddNodeEx", + "original_fully_qualified_name": "ImGui::DockBuilderAddNode", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3663 + } + }, + { + "name": "ImGui_DockBuilderRemoveNode", + "original_fully_qualified_name": "ImGui::DockBuilderRemoveNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Remove node and all its child, undock all windows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3664 + } + }, + { + "name": "ImGui_DockBuilderRemoveNodeDockedWindows", + "original_fully_qualified_name": "ImGui::DockBuilderRemoveNodeDockedWindows", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied clear_settings_refs = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3665 + } + }, + { + "name": "ImGui_DockBuilderRemoveNodeDockedWindowsEx", + "original_fully_qualified_name": "ImGui::DockBuilderRemoveNodeDockedWindows", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clear_settings_refs", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3665 + } + }, + { + "name": "ImGui_DockBuilderRemoveNodeChildNodes", + "original_fully_qualified_name": "ImGui::DockBuilderRemoveNodeChildNodes", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Remove all split/hierarchy. All remaining docked windows will be re-docked to the remaining root node (node_id)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3666 + } + }, + { + "name": "ImGui_DockBuilderSetNodePos", + "original_fully_qualified_name": "ImGui::DockBuilderSetNodePos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3667 + } + }, + { + "name": "ImGui_DockBuilderSetNodeSize", + "original_fully_qualified_name": "ImGui::DockBuilderSetNodeSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3668 + } + }, + { + "name": "ImGui_DockBuilderSplitNode", + "original_fully_qualified_name": "ImGui::DockBuilderSplitNode", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "split_dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_ratio_for_node_at_dir", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_id_at_dir", + "type": { + "declaration": "ImGuiID*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiID" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_id_at_opposite_dir", + "type": { + "declaration": "ImGuiID*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiID" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Create 2 child nodes in this parent node." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3669 + } + }, + { + "name": "ImGui_DockBuilderCopyDockSpace", + "original_fully_qualified_name": "ImGui::DockBuilderCopyDockSpace", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "src_dockspace_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_dockspace_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_window_remap_pairs", + "type": { + "declaration": "ImVector_const_charPtr*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_const_charPtr" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3670 + } + }, + { + "name": "ImGui_DockBuilderCopyNode", + "original_fully_qualified_name": "ImGui::DockBuilderCopyNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "src_node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_node_remap_pairs", + "type": { + "declaration": "ImVector_ImGuiID*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_ImGuiID" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3671 + } + }, + { + "name": "ImGui_DockBuilderCopyWindowSettings", + "original_fully_qualified_name": "ImGui::DockBuilderCopyWindowSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "src_name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3672 + } + }, + { + "name": "ImGui_DockBuilderFinish", + "original_fully_qualified_name": "ImGui::DockBuilderFinish", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3673 + } + }, + { + "name": "ImGui_PushFocusScope", + "original_fully_qualified_name": "ImGui::PushFocusScope", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// [EXPERIMENTAL] Focus Scope", + "// This is generally used to identify a unique input location (for e.g. a selection set)", + "// There is one per window (automatically set in Begin), but:", + "// - Selection patterns generally need to react (e.g. clear a selection) when landing on one item of the set.", + "// So in order to identify a set multiple lists in same window may each need a focus scope.", + "// If you imagine an hypothetical BeginSelectionGroup()/EndSelectionGroup() api, it would likely call PushFocusScope()/EndFocusScope()", + "// - Shortcut routing also use focus scope as a default location identifier if an owner is not provided.", + "// We don't use the ID Stack for this as it is common to want them separate." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3683 + } + }, + { + "name": "ImGui_PopFocusScope", + "original_fully_qualified_name": "ImGui::PopFocusScope", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3684 + } + }, + { + "name": "ImGui_GetCurrentFocusScope", + "original_fully_qualified_name": "ImGui::GetCurrentFocusScope", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Focus scope we are outputting into, set by PushFocusScope()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3685 + } + }, + { + "name": "ImGui_IsDragDropActive", + "original_fully_qualified_name": "ImGui::IsDragDropActive", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Drag and Drop" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3688 + } + }, + { + "name": "ImGui_BeginDragDropTargetCustom", + "original_fully_qualified_name": "ImGui::BeginDragDropTargetCustom", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3689 + } + }, + { + "name": "ImGui_ClearDragDrop", + "original_fully_qualified_name": "ImGui::ClearDragDrop", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3690 + } + }, + { + "name": "ImGui_IsDragDropPayloadBeingAccepted", + "original_fully_qualified_name": "ImGui::IsDragDropPayloadBeingAccepted", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3691 + } + }, + { + "name": "ImGui_RenderDragDropTargetRect", + "original_fully_qualified_name": "ImGui::RenderDragDropTargetRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "item_clip_rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3692 + } + }, + { + "name": "ImGui_GetTypingSelectRequest", + "original_fully_qualified_name": "ImGui::GetTypingSelectRequest", + "return_type": { + "declaration": "ImGuiTypingSelectRequest*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTypingSelectRequest" + } + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Typing-Select API", + "// (provide Windows Explorer style \"select items by typing partial name\" + \"cycle through items by typing same letter\" feature)", + "// (this is currently not documented nor used by main library, but should work. See \"widgets_typingselect\" in imgui_test_suite for usage code. Please let us know if you use this!)" + ], + "attached": "// Implied flags = ImGuiTypingSelectFlags_None" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3697 + } + }, + { + "name": "ImGui_GetTypingSelectRequestEx", + "original_fully_qualified_name": "ImGui::GetTypingSelectRequest", + "return_type": { + "declaration": "ImGuiTypingSelectRequest*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTypingSelectRequest" + } + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiTypingSelectFlags", + "description": { + "kind": "User", + "name": "ImGuiTypingSelectFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImGuiTypingSelectFlags_None", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3697 + } + }, + { + "name": "ImGui_TypingSelectFindMatch", + "original_fully_qualified_name": "ImGui::TypingSelectFindMatch", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "req", + "type": { + "declaration": "ImGuiTypingSelectRequest*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTypingSelectRequest" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "get_item_name_func", + "type": { + "declaration": "const char* (*get_item_name_func)(void*, int)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "get_item_name_func", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + { + "kind": "Builtin", + "builtin_type": "int" + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "nav_item_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3698 + } + }, + { + "name": "ImGui_TypingSelectFindNextSingleCharMatch", + "original_fully_qualified_name": "ImGui::TypingSelectFindNextSingleCharMatch", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "req", + "type": { + "declaration": "ImGuiTypingSelectRequest*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTypingSelectRequest" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "get_item_name_func", + "type": { + "declaration": "const char* (*get_item_name_func)(void*, int)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "get_item_name_func", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + { + "kind": "Builtin", + "builtin_type": "int" + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "nav_item_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3699 + } + }, + { + "name": "ImGui_TypingSelectFindBestLeadingMatch", + "original_fully_qualified_name": "ImGui::TypingSelectFindBestLeadingMatch", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "req", + "type": { + "declaration": "ImGuiTypingSelectRequest*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTypingSelectRequest" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "get_item_name_func", + "type": { + "declaration": "const char* (*get_item_name_func)(void*, int)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "get_item_name_func", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + { + "kind": "Builtin", + "builtin_type": "int" + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3700 + } + }, + { + "name": "ImGui_BeginBoxSelect", + "original_fully_qualified_name": "ImGui::BeginBoxSelect", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "scope_rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "box_select_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "ms_flags", + "type": { + "declaration": "ImGuiMultiSelectFlags", + "description": { + "kind": "User", + "name": "ImGuiMultiSelectFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Box-Select API" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3703 + } + }, + { + "name": "ImGui_EndBoxSelect", + "original_fully_qualified_name": "ImGui::EndBoxSelect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "scope_rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "ms_flags", + "type": { + "declaration": "ImGuiMultiSelectFlags", + "description": { + "kind": "User", + "name": "ImGuiMultiSelectFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3704 + } + }, + { + "name": "ImGui_MultiSelectItemHeader", + "original_fully_qualified_name": "ImGui::MultiSelectItemHeader", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_selected", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_button_flags", + "type": { + "declaration": "ImGuiButtonFlags*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiButtonFlags" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Multi-Select API" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3707 + } + }, + { + "name": "ImGui_MultiSelectItemFooter", + "original_fully_qualified_name": "ImGui::MultiSelectItemFooter", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_selected", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_pressed", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3708 + } + }, + { + "name": "ImGui_MultiSelectAddSetAll", + "original_fully_qualified_name": "ImGui::MultiSelectAddSetAll", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ms", + "type": { + "declaration": "ImGuiMultiSelectTempData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectTempData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "selected", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3709 + } + }, + { + "name": "ImGui_MultiSelectAddSetRange", + "original_fully_qualified_name": "ImGui::MultiSelectAddSetRange", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ms", + "type": { + "declaration": "ImGuiMultiSelectTempData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectTempData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "selected", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "range_dir", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "first_item", + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "last_item", + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3710 + } + }, + { + "name": "ImGui_GetBoxSelectState", + "original_fully_qualified_name": "ImGui::GetBoxSelectState", + "return_type": { + "declaration": "ImGuiBoxSelectState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiBoxSelectState" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3711 + } + }, + { + "name": "ImGui_GetMultiSelectState", + "original_fully_qualified_name": "ImGui::GetMultiSelectState", + "return_type": { + "declaration": "ImGuiMultiSelectState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectState" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3712 + } + }, + { + "name": "ImGui_SetWindowClipRectBeforeSetChannel", + "original_fully_qualified_name": "ImGui::SetWindowClipRectBeforeSetChannel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clip_rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Internal Columns API (this is not exposed because we will encourage transitioning to the Tables API)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3715 + } + }, + { + "name": "ImGui_BeginColumns", + "original_fully_qualified_name": "ImGui::BeginColumns", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiOldColumnFlags", + "description": { + "kind": "User", + "name": "ImGuiOldColumnFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3716 + } + }, + { + "name": "ImGui_EndColumns", + "original_fully_qualified_name": "ImGui::EndColumns", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// close columns" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3717 + } + }, + { + "name": "ImGui_PushColumnClipRect", + "original_fully_qualified_name": "ImGui::PushColumnClipRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3718 + } + }, + { + "name": "ImGui_PushColumnsBackground", + "original_fully_qualified_name": "ImGui::PushColumnsBackground", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3719 + } + }, + { + "name": "ImGui_PopColumnsBackground", + "original_fully_qualified_name": "ImGui::PopColumnsBackground", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3720 + } + }, + { + "name": "ImGui_GetColumnsID", + "original_fully_qualified_name": "ImGui::GetColumnsID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3721 + } + }, + { + "name": "ImGui_FindOrCreateColumns", + "original_fully_qualified_name": "ImGui::FindOrCreateColumns", + "return_type": { + "declaration": "ImGuiOldColumns*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiOldColumns" + } + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3722 + } + }, + { + "name": "ImGui_GetColumnOffsetFromNorm", + "original_fully_qualified_name": "ImGui::GetColumnOffsetFromNorm", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "columns", + "type": { + "declaration": "const ImGuiOldColumns*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiOldColumns", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "offset_norm", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3723 + } + }, + { + "name": "ImGui_GetColumnNormFromOffset", + "original_fully_qualified_name": "ImGui::GetColumnNormFromOffset", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "columns", + "type": { + "declaration": "const ImGuiOldColumns*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiOldColumns", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "offset", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3724 + } + }, + { + "name": "ImGui_TableOpenContextMenu", + "original_fully_qualified_name": "ImGui::TableOpenContextMenu", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tables: Candidates for public API" + ], + "attached": "// Implied column_n = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3727 + } + }, + { + "name": "ImGui_TableOpenContextMenuEx", + "original_fully_qualified_name": "ImGui::TableOpenContextMenu", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3727 + } + }, + { + "name": "ImGui_TableSetColumnWidth", + "original_fully_qualified_name": "ImGui::TableSetColumnWidth", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3728 + } + }, + { + "name": "ImGui_TableSetColumnSortDirection", + "original_fully_qualified_name": "ImGui::TableSetColumnSortDirection", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sort_direction", + "type": { + "declaration": "ImGuiSortDirection", + "description": { + "kind": "User", + "name": "ImGuiSortDirection" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "append_to_sort_specs", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3729 + } + }, + { + "name": "ImGui_TableGetHoveredRow", + "original_fully_qualified_name": "ImGui::TableGetHoveredRow", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Retrieve *PREVIOUS FRAME* hovered row. This difference with TableGetHoveredColumn() is the reason why this is not public yet." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3730 + } + }, + { + "name": "ImGui_TableGetHeaderRowHeight", + "original_fully_qualified_name": "ImGui::TableGetHeaderRowHeight", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3731 + } + }, + { + "name": "ImGui_TableGetHeaderAngledMaxLabelWidth", + "original_fully_qualified_name": "ImGui::TableGetHeaderAngledMaxLabelWidth", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3732 + } + }, + { + "name": "ImGui_TablePushBackgroundChannel", + "original_fully_qualified_name": "ImGui::TablePushBackgroundChannel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3733 + } + }, + { + "name": "ImGui_TablePopBackgroundChannel", + "original_fully_qualified_name": "ImGui::TablePopBackgroundChannel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3734 + } + }, + { + "name": "ImGui_TablePushColumnChannel", + "original_fully_qualified_name": "ImGui::TablePushColumnChannel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3735 + } + }, + { + "name": "ImGui_TablePopColumnChannel", + "original_fully_qualified_name": "ImGui::TablePopColumnChannel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3736 + } + }, + { + "name": "ImGui_TableAngledHeadersRowEx", + "original_fully_qualified_name": "ImGui::TableAngledHeadersRowEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "row_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "angle", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "max_label_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "const ImGuiTableHeaderData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableHeaderData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3737 + } + }, + { + "name": "ImGui_GetCurrentTable", + "original_fully_qualified_name": "ImGui::GetCurrentTable", + "return_type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tables: Internals" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3740 + } + }, + { + "name": "ImGui_TableFindByID", + "original_fully_qualified_name": "ImGui::TableFindByID", + "return_type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3741 + } + }, + { + "name": "ImGui_BeginTableWithID", + "original_fully_qualified_name": "ImGui::BeginTableEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "columns_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied outer_size = ImVec2(0, 0), inner_width = 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3742 + } + }, + { + "name": "ImGui_BeginTableWithIDEx", + "original_fully_qualified_name": "ImGui::BeginTableEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "columns_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "outer_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "inner_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3742 + } + }, + { + "name": "ImGui_TableBeginInitMemory", + "original_fully_qualified_name": "ImGui::TableBeginInitMemory", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "columns_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3743 + } + }, + { + "name": "ImGui_TableBeginApplyRequests", + "original_fully_qualified_name": "ImGui::TableBeginApplyRequests", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3744 + } + }, + { + "name": "ImGui_TableSetupDrawChannels", + "original_fully_qualified_name": "ImGui::TableSetupDrawChannels", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3745 + } + }, + { + "name": "ImGui_TableUpdateLayout", + "original_fully_qualified_name": "ImGui::TableUpdateLayout", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3746 + } + }, + { + "name": "ImGui_TableUpdateBorders", + "original_fully_qualified_name": "ImGui::TableUpdateBorders", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3747 + } + }, + { + "name": "ImGui_TableUpdateColumnsWeightFromWidth", + "original_fully_qualified_name": "ImGui::TableUpdateColumnsWeightFromWidth", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3748 + } + }, + { + "name": "ImGui_TableDrawBorders", + "original_fully_qualified_name": "ImGui::TableDrawBorders", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3749 + } + }, + { + "name": "ImGui_TableDrawDefaultContextMenu", + "original_fully_qualified_name": "ImGui::TableDrawDefaultContextMenu", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags_for_section_to_display", + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3750 + } + }, + { + "name": "ImGui_TableBeginContextMenuPopup", + "original_fully_qualified_name": "ImGui::TableBeginContextMenuPopup", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3751 + } + }, + { + "name": "ImGui_TableMergeDrawChannels", + "original_fully_qualified_name": "ImGui::TableMergeDrawChannels", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3752 + } + }, + { + "name": "ImGui_TableGetInstanceData", + "original_fully_qualified_name": "ImGui::TableGetInstanceData", + "return_type": { + "declaration": "ImGuiTableInstanceData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableInstanceData" + } + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "instance_no", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3753 + } + }, + { + "name": "ImGui_TableGetInstanceID", + "original_fully_qualified_name": "ImGui::TableGetInstanceID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "instance_no", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3754 + } + }, + { + "name": "ImGui_TableSortSpecsSanitize", + "original_fully_qualified_name": "ImGui::TableSortSpecsSanitize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3755 + } + }, + { + "name": "ImGui_TableSortSpecsBuild", + "original_fully_qualified_name": "ImGui::TableSortSpecsBuild", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3756 + } + }, + { + "name": "ImGui_TableGetColumnNextSortDirection", + "original_fully_qualified_name": "ImGui::TableGetColumnNextSortDirection", + "return_type": { + "declaration": "ImGuiSortDirection", + "description": { + "kind": "User", + "name": "ImGuiSortDirection" + } + }, + "arguments": [ + { + "name": "column", + "type": { + "declaration": "ImGuiTableColumn*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumn" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3757 + } + }, + { + "name": "ImGui_TableFixColumnSortDirection", + "original_fully_qualified_name": "ImGui::TableFixColumnSortDirection", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column", + "type": { + "declaration": "ImGuiTableColumn*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumn" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3758 + } + }, + { + "name": "ImGui_TableGetColumnWidthAuto", + "original_fully_qualified_name": "ImGui::TableGetColumnWidthAuto", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column", + "type": { + "declaration": "ImGuiTableColumn*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumn" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3759 + } + }, + { + "name": "ImGui_TableBeginRow", + "original_fully_qualified_name": "ImGui::TableBeginRow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3760 + } + }, + { + "name": "ImGui_TableEndRow", + "original_fully_qualified_name": "ImGui::TableEndRow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3761 + } + }, + { + "name": "ImGui_TableBeginCell", + "original_fully_qualified_name": "ImGui::TableBeginCell", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3762 + } + }, + { + "name": "ImGui_TableEndCell", + "original_fully_qualified_name": "ImGui::TableEndCell", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3763 + } + }, + { + "name": "ImGui_TableGetCellBgRect", + "original_fully_qualified_name": "ImGui::TableGetCellBgRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "const ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3764 + } + }, + { + "name": "ImGui_TableGetColumnNameImGuiTablePtr", + "original_fully_qualified_name": "ImGui::TableGetColumnName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "const ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3765 + } + }, + { + "name": "ImGui_TableGetColumnResizeID", + "original_fully_qualified_name": "ImGui::TableGetColumnResizeID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied instance_no = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3766 + } + }, + { + "name": "ImGui_TableGetColumnResizeIDEx", + "original_fully_qualified_name": "ImGui::TableGetColumnResizeID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "instance_no", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3766 + } + }, + { + "name": "ImGui_TableCalcMaxColumnWidth", + "original_fully_qualified_name": "ImGui::TableCalcMaxColumnWidth", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "const ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3767 + } + }, + { + "name": "ImGui_TableSetColumnWidthAutoSingle", + "original_fully_qualified_name": "ImGui::TableSetColumnWidthAutoSingle", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3768 + } + }, + { + "name": "ImGui_TableSetColumnWidthAutoAll", + "original_fully_qualified_name": "ImGui::TableSetColumnWidthAutoAll", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3769 + } + }, + { + "name": "ImGui_TableRemove", + "original_fully_qualified_name": "ImGui::TableRemove", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3770 + } + }, + { + "name": "ImGui_TableGcCompactTransientBuffers", + "original_fully_qualified_name": "ImGui::TableGcCompactTransientBuffers", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3771 + } + }, + { + "name": "ImGui_TableGcCompactTransientBuffersImGuiTableTempDataPtr", + "original_fully_qualified_name": "ImGui::TableGcCompactTransientBuffers", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTableTempData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableTempData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3772 + } + }, + { + "name": "ImGui_TableGcCompactSettings", + "original_fully_qualified_name": "ImGui::TableGcCompactSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3773 + } + }, + { + "name": "ImGui_TableLoadSettings", + "original_fully_qualified_name": "ImGui::TableLoadSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tables: Settings" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3776 + } + }, + { + "name": "ImGui_TableSaveSettings", + "original_fully_qualified_name": "ImGui::TableSaveSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3777 + } + }, + { + "name": "ImGui_TableResetSettings", + "original_fully_qualified_name": "ImGui::TableResetSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3778 + } + }, + { + "name": "ImGui_TableGetBoundSettings", + "original_fully_qualified_name": "ImGui::TableGetBoundSettings", + "return_type": { + "declaration": "ImGuiTableSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableSettings" + } + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3779 + } + }, + { + "name": "ImGui_TableSettingsAddSettingsHandler", + "original_fully_qualified_name": "ImGui::TableSettingsAddSettingsHandler", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3780 + } + }, + { + "name": "ImGui_TableSettingsCreate", + "original_fully_qualified_name": "ImGui::TableSettingsCreate", + "return_type": { + "declaration": "ImGuiTableSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableSettings" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "columns_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3781 + } + }, + { + "name": "ImGui_TableSettingsFindByID", + "original_fully_qualified_name": "ImGui::TableSettingsFindByID", + "return_type": { + "declaration": "ImGuiTableSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableSettings" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3782 + } + }, + { + "name": "ImGui_GetCurrentTabBar", + "original_fully_qualified_name": "ImGui::GetCurrentTabBar", + "return_type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tab Bars" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3785 + } + }, + { + "name": "ImGui_BeginTabBarEx", + "original_fully_qualified_name": "ImGui::BeginTabBarEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabBarFlags", + "description": { + "kind": "User", + "name": "ImGuiTabBarFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3786 + } + }, + { + "name": "ImGui_TabBarFindTabByID", + "original_fully_qualified_name": "ImGui::TabBarFindTabByID", + "return_type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3787 + } + }, + { + "name": "ImGui_TabBarFindTabByOrder", + "original_fully_qualified_name": "ImGui::TabBarFindTabByOrder", + "return_type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "order", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3788 + } + }, + { + "name": "ImGui_TabBarFindMostRecentlySelectedTabForActiveWindow", + "original_fully_qualified_name": "ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow", + "return_type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3789 + } + }, + { + "name": "ImGui_TabBarGetCurrentTab", + "original_fully_qualified_name": "ImGui::TabBarGetCurrentTab", + "return_type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3790 + } + }, + { + "name": "ImGui_TabBarGetTabOrder", + "original_fully_qualified_name": "ImGui::TabBarGetTabOrder", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab", + "type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3791 + } + }, + { + "name": "ImGui_TabBarGetTabName", + "original_fully_qualified_name": "ImGui::TabBarGetTabName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab", + "type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3792 + } + }, + { + "name": "ImGui_TabBarAddTab", + "original_fully_qualified_name": "ImGui::TabBarAddTab", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab_flags", + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3793 + } + }, + { + "name": "ImGui_TabBarRemoveTab", + "original_fully_qualified_name": "ImGui::TabBarRemoveTab", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3794 + } + }, + { + "name": "ImGui_TabBarCloseTab", + "original_fully_qualified_name": "ImGui::TabBarCloseTab", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab", + "type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3795 + } + }, + { + "name": "ImGui_TabBarQueueFocus", + "original_fully_qualified_name": "ImGui::TabBarQueueFocus", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab", + "type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3796 + } + }, + { + "name": "ImGui_TabBarQueueFocusStr", + "original_fully_qualified_name": "ImGui::TabBarQueueFocus", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab_name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3797 + } + }, + { + "name": "ImGui_TabBarQueueReorder", + "original_fully_qualified_name": "ImGui::TabBarQueueReorder", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab", + "type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "offset", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3798 + } + }, + { + "name": "ImGui_TabBarQueueReorderFromMousePos", + "original_fully_qualified_name": "ImGui::TabBarQueueReorderFromMousePos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab", + "type": { + "declaration": "ImGuiTabItem*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabItem" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "mouse_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3799 + } + }, + { + "name": "ImGui_TabBarProcessReorder", + "original_fully_qualified_name": "ImGui::TabBarProcessReorder", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3800 + } + }, + { + "name": "ImGui_TabItemEx", + "original_fully_qualified_name": "ImGui::TabItemEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "docked_window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3801 + } + }, + { + "name": "ImGui_TabItemSpacing", + "original_fully_qualified_name": "ImGui::TabItemSpacing", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3802 + } + }, + { + "name": "ImGui_TabItemCalcSizeStr", + "original_fully_qualified_name": "ImGui::TabItemCalcSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "has_close_button_or_unsaved_marker", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3803 + } + }, + { + "name": "ImGui_TabItemCalcSize", + "original_fully_qualified_name": "ImGui::TabItemCalcSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3804 + } + }, + { + "name": "ImGui_TabItemBackground", + "original_fully_qualified_name": "ImGui::TabItemBackground", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3805 + } + }, + { + "name": "ImGui_TabItemLabelAndCloseButton", + "original_fully_qualified_name": "ImGui::TabItemLabelAndCloseButton", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "frame_padding", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tab_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "close_button_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "is_contents_visible", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_just_closed", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_text_clipped", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3806 + } + }, + { + "name": "ImGui_RenderText", + "original_fully_qualified_name": "ImGui::RenderText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Render helpers", + "// AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.", + "// NB: All position are in absolute pixels coordinates (we are never using window coordinates internally)" + ], + "attached": "// Implied text_end = NULL, hide_text_after_hash = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3811 + } + }, + { + "name": "ImGui_RenderTextEx", + "original_fully_qualified_name": "ImGui::RenderText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "hide_text_after_hash", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3811 + } + }, + { + "name": "ImGui_RenderTextWrapped", + "original_fully_qualified_name": "ImGui::RenderTextWrapped", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3812 + } + }, + { + "name": "ImGui_RenderTextClipped", + "original_fully_qualified_name": "ImGui::RenderTextClipped", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_size_if_known", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied align = ImVec2(0, 0), clip_rect = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3813 + } + }, + { + "name": "ImGui_RenderTextClippedEx", + "original_fully_qualified_name": "ImGui::RenderTextClipped", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_size_if_known", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "align", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "clip_rect", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3813 + } + }, + { + "name": "ImGui_RenderTextClippedWithDrawList", + "original_fully_qualified_name": "ImGui::RenderTextClippedEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_size_if_known", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied align = ImVec2(0, 0), clip_rect = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3814 + } + }, + { + "name": "ImGui_RenderTextClippedWithDrawListEx", + "original_fully_qualified_name": "ImGui::RenderTextClippedEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_size_if_known", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "align", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "clip_rect", + "type": { + "declaration": "const ImRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3814 + } + }, + { + "name": "ImGui_RenderTextEllipsis", + "original_fully_qualified_name": "ImGui::RenderTextEllipsis", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "ellipsis_max_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_size_if_known", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3815 + } + }, + { + "name": "ImGui_RenderFrame", + "original_fully_qualified_name": "ImGui::RenderFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fill_col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied borders = true, rounding = 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3816 + } + }, + { + "name": "ImGui_RenderFrameEx", + "original_fully_qualified_name": "ImGui::RenderFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fill_col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "borders", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3816 + } + }, + { + "name": "ImGui_RenderFrameBorder", + "original_fully_qualified_name": "ImGui::RenderFrameBorder", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied rounding = 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3817 + } + }, + { + "name": "ImGui_RenderFrameBorderEx", + "original_fully_qualified_name": "ImGui::RenderFrameBorder", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3817 + } + }, + { + "name": "ImGui_RenderColorRectWithAlphaCheckerboard", + "original_fully_qualified_name": "ImGui::RenderColorRectWithAlphaCheckerboard", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fill_col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "grid_step", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "grid_off", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied rounding = 0.0f, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3818 + } + }, + { + "name": "ImGui_RenderColorRectWithAlphaCheckerboardEx", + "original_fully_qualified_name": "ImGui::RenderColorRectWithAlphaCheckerboard", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fill_col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "grid_step", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "grid_off", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3818 + } + }, + { + "name": "ImGui_RenderNavCursor", + "original_fully_qualified_name": "ImGui::RenderNavCursor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied flags = ImGuiNavRenderCursorFlags_None" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3819 + } + }, + { + "name": "ImGui_RenderNavCursorEx", + "original_fully_qualified_name": "ImGui::RenderNavCursor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiNavRenderCursorFlags", + "description": { + "kind": "User", + "name": "ImGuiNavRenderCursorFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImGuiNavRenderCursorFlags_None", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Navigation highlight" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3819 + } + }, + { + "name": "ImGui_RenderNavHighlight", + "original_fully_qualified_name": "ImGui::RenderNavHighlight", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied flags = ImGuiNavRenderCursorFlags_None" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3821 + } + }, + { + "name": "ImGui_RenderNavHighlightEx", + "original_fully_qualified_name": "ImGui::RenderNavHighlight", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiNavRenderCursorFlags", + "description": { + "kind": "User", + "name": "ImGuiNavRenderCursorFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImGuiNavRenderCursorFlags_None", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Renamed in 1.91.4" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3821 + } + }, + { + "name": "ImGui_FindRenderedTextEnd", + "original_fully_qualified_name": "ImGui::FindRenderedTextEnd", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied text_end = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3823 + } + }, + { + "name": "ImGui_FindRenderedTextEndEx", + "original_fully_qualified_name": "ImGui::FindRenderedTextEnd", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Find the optional ## from which we stop displaying text." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3823 + } + }, + { + "name": "ImGui_RenderMouseCursor", + "original_fully_qualified_name": "ImGui::RenderMouseCursor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scale", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "mouse_cursor", + "type": { + "declaration": "ImGuiMouseCursor", + "description": { + "kind": "User", + "name": "ImGuiMouseCursor" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_fill", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_border", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_shadow", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3824 + } + }, + { + "name": "ImGui_RenderArrow", + "original_fully_qualified_name": "ImGui::RenderArrow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Render helpers (those functions don't access any ImGui state!)" + ], + "attached": "// Implied scale = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3827 + } + }, + { + "name": "ImGui_RenderArrowEx", + "original_fully_qualified_name": "ImGui::RenderArrow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scale", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3827 + } + }, + { + "name": "ImGui_RenderBullet", + "original_fully_qualified_name": "ImGui::RenderBullet", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3828 + } + }, + { + "name": "ImGui_RenderCheckMark", + "original_fully_qualified_name": "ImGui::RenderCheckMark", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3829 + } + }, + { + "name": "ImGui_RenderArrowPointingAt", + "original_fully_qualified_name": "ImGui::RenderArrowPointingAt", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "half_sz", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "direction", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3830 + } + }, + { + "name": "ImGui_RenderArrowDockMenu", + "original_fully_qualified_name": "ImGui::RenderArrowDockMenu", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3831 + } + }, + { + "name": "ImGui_RenderRectFilledRangeH", + "original_fully_qualified_name": "ImGui::RenderRectFilledRangeH", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rect", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "x_start_norm", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "x_end_norm", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3832 + } + }, + { + "name": "ImGui_RenderRectFilledWithHole", + "original_fully_qualified_name": "ImGui::RenderRectFilledWithHole", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "outer", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "inner", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3833 + } + }, + { + "name": "ImGui_CalcRoundingFlagsForRectInRect", + "original_fully_qualified_name": "ImGui::CalcRoundingFlagsForRectInRect", + "return_type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "arguments": [ + { + "name": "r_in", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r_outer", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "threshold", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3834 + } + }, + { + "name": "ImGui_TextEx", + "original_fully_qualified_name": "ImGui::TextEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Text" + ], + "attached": "// Implied text_end = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3837 + } + }, + { + "name": "ImGui_TextExEx", + "original_fully_qualified_name": "ImGui::TextEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTextFlags", + "description": { + "kind": "User", + "name": "ImGuiTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3837 + } + }, + { + "name": "ImGui_TextAligned", + "original_fully_qualified_name": "ImGui::TextAligned", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "align_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg3__", + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// FIXME-WIP: Works but API is likely to be reworked. This is designed for 1 item on the line. (#7024)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3838 + } + }, + { + "name": "ImGui_TextAlignedV", + "original_fully_qualified_name": "ImGui::TextAlignedV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "align_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3839 + } + }, + { + "name": "ImGui_ButtonWithFlags", + "original_fully_qualified_name": "ImGui::ButtonEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets" + ], + "attached": "// Implied size_arg = ImVec2(0, 0), flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3842 + } + }, + { + "name": "ImGui_ButtonWithFlagsEx", + "original_fully_qualified_name": "ImGui::ButtonEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_arg", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiButtonFlags", + "description": { + "kind": "User", + "name": "ImGuiButtonFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3842 + } + }, + { + "name": "ImGui_ArrowButtonEx", + "original_fully_qualified_name": "ImGui::ArrowButtonEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_arg", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiButtonFlags", + "description": { + "kind": "User", + "name": "ImGuiButtonFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3843 + } + }, + { + "name": "ImGui_ImageButtonWithFlags", + "original_fully_qualified_name": "ImGui::ImageButtonEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv0", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bg_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tint_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiButtonFlags", + "description": { + "kind": "User", + "name": "ImGuiButtonFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3844 + } + }, + { + "name": "ImGui_SeparatorEx", + "original_fully_qualified_name": "ImGui::SeparatorEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiSeparatorFlags", + "description": { + "kind": "User", + "name": "ImGuiSeparatorFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3845 + } + }, + { + "name": "ImGui_SeparatorExEx", + "original_fully_qualified_name": "ImGui::SeparatorEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiSeparatorFlags", + "description": { + "kind": "User", + "name": "ImGuiSeparatorFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3845 + } + }, + { + "name": "ImGui_SeparatorTextEx", + "original_fully_qualified_name": "ImGui::SeparatorTextEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "extra_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3846 + } + }, + { + "name": "ImGui_CheckboxFlagsImS64Ptr", + "original_fully_qualified_name": "ImGui::CheckboxFlags", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImS64*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImS64" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags_value", + "type": { + "declaration": "ImS64", + "description": { + "kind": "User", + "name": "ImS64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3847 + } + }, + { + "name": "ImGui_CheckboxFlagsImU64Ptr", + "original_fully_qualified_name": "ImGui::CheckboxFlags", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImU64*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU64" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags_value", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3848 + } + }, + { + "name": "ImGui_CloseButton", + "original_fully_qualified_name": "ImGui::CloseButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Window Decorations" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3851 + } + }, + { + "name": "ImGui_CollapseButton", + "original_fully_qualified_name": "ImGui::CollapseButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dock_node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3852 + } + }, + { + "name": "ImGui_Scrollbar", + "original_fully_qualified_name": "ImGui::Scrollbar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3853 + } + }, + { + "name": "ImGui_ScrollbarEx", + "original_fully_qualified_name": "ImGui::ScrollbarEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_scroll_v", + "type": { + "declaration": "ImS64*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImS64" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "avail_v", + "type": { + "declaration": "ImS64", + "description": { + "kind": "User", + "name": "ImS64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "contents_v", + "type": { + "declaration": "ImS64", + "description": { + "kind": "User", + "name": "ImS64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied draw_rounding_flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3854 + } + }, + { + "name": "ImGui_ScrollbarExEx", + "original_fully_qualified_name": "ImGui::ScrollbarEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_scroll_v", + "type": { + "declaration": "ImS64*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImS64" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "avail_v", + "type": { + "declaration": "ImS64", + "description": { + "kind": "User", + "name": "ImS64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "contents_v", + "type": { + "declaration": "ImS64", + "description": { + "kind": "User", + "name": "ImS64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "draw_rounding_flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3854 + } + }, + { + "name": "ImGui_GetWindowScrollbarRect", + "original_fully_qualified_name": "ImGui::GetWindowScrollbarRect", + "return_type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3855 + } + }, + { + "name": "ImGui_GetWindowScrollbarID", + "original_fully_qualified_name": "ImGui::GetWindowScrollbarID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3856 + } + }, + { + "name": "ImGui_GetWindowResizeCornerID", + "original_fully_qualified_name": "ImGui::GetWindowResizeCornerID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// 0..3: corners" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3857 + } + }, + { + "name": "ImGui_GetWindowResizeBorderID", + "original_fully_qualified_name": "ImGui::GetWindowResizeBorderID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3858 + } + }, + { + "name": "ImGui_ButtonBehavior", + "original_fully_qualified_name": "ImGui::ButtonBehavior", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_hovered", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_held", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiButtonFlags", + "description": { + "kind": "User", + "name": "ImGuiButtonFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets low-level behaviors" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3861 + } + }, + { + "name": "ImGui_DragBehavior", + "original_fully_qualified_name": "ImGui::DragBehavior", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_v", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3862 + } + }, + { + "name": "ImGui_SliderBehavior", + "original_fully_qualified_name": "ImGui::SliderBehavior", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_v", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_grab_bb", + "type": { + "declaration": "ImRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3863 + } + }, + { + "name": "ImGui_SplitterBehavior", + "original_fully_qualified_name": "ImGui::SplitterBehavior", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size1", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size2", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "min_size1", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "min_size2", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied hover_extend = 0.0f, hover_visibility_delay = 0.0f, bg_col = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3864 + } + }, + { + "name": "ImGui_SplitterBehaviorEx", + "original_fully_qualified_name": "ImGui::SplitterBehavior", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "axis", + "type": { + "declaration": "ImGuiAxis", + "description": { + "kind": "User", + "name": "ImGuiAxis" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size1", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size2", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "min_size1", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "min_size2", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hover_extend", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "hover_visibility_delay", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "bg_col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3864 + } + }, + { + "name": "ImGui_TreeNodeBehavior", + "original_fully_qualified_name": "ImGui::TreeNodeBehavior", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Tree Nodes" + ], + "attached": "// Implied label_end = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3867 + } + }, + { + "name": "ImGui_TreeNodeBehaviorEx", + "original_fully_qualified_name": "ImGui::TreeNodeBehavior", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3867 + } + }, + { + "name": "ImGui_TreeNodeDrawLineToChildNode", + "original_fully_qualified_name": "ImGui::TreeNodeDrawLineToChildNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "target_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3868 + } + }, + { + "name": "ImGui_TreeNodeDrawLineToTreePop", + "original_fully_qualified_name": "ImGui::TreeNodeDrawLineToTreePop", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "const ImGuiTreeNodeStackData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTreeNodeStackData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3869 + } + }, + { + "name": "ImGui_TreePushOverrideID", + "original_fully_qualified_name": "ImGui::TreePushOverrideID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3870 + } + }, + { + "name": "ImGui_TreeNodeGetOpen", + "original_fully_qualified_name": "ImGui::TreeNodeGetOpen", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "storage_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3871 + } + }, + { + "name": "ImGui_TreeNodeSetOpen", + "original_fully_qualified_name": "ImGui::TreeNodeSetOpen", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "storage_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "open", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3872 + } + }, + { + "name": "ImGui_TreeNodeUpdateNextOpen", + "original_fully_qualified_name": "ImGui::TreeNodeUpdateNextOpen", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "storage_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Return open state. Consume previous SetNextItemOpen() data, if any. May return true when logging." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3873 + } + }, + { + "name": "ImGui_DataTypeGetInfo", + "original_fully_qualified_name": "ImGui::DataTypeGetInfo", + "return_type": { + "declaration": "const ImGuiDataTypeInfo*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDataTypeInfo", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Data type helpers" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3886 + } + }, + { + "name": "ImGui_DataTypeFormatString", + "original_fully_qualified_name": "ImGui::DataTypeFormatString", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3887 + } + }, + { + "name": "ImGui_DataTypeApplyOp", + "original_fully_qualified_name": "ImGui::DataTypeApplyOp", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "op", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "output", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "arg_1", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "arg_2", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3888 + } + }, + { + "name": "ImGui_DataTypeApplyFromText", + "original_fully_qualified_name": "ImGui::DataTypeApplyFromText", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "buf", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied p_data_when_empty = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3889 + } + }, + { + "name": "ImGui_DataTypeApplyFromTextEx", + "original_fully_qualified_name": "ImGui::DataTypeApplyFromText", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "buf", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data_when_empty", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3889 + } + }, + { + "name": "ImGui_DataTypeCompare", + "original_fully_qualified_name": "ImGui::DataTypeCompare", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "arg_1", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "arg_2", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3890 + } + }, + { + "name": "ImGui_DataTypeClamp", + "original_fully_qualified_name": "ImGui::DataTypeClamp", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3891 + } + }, + { + "name": "ImGui_DataTypeIsZero", + "original_fully_qualified_name": "ImGui::DataTypeIsZero", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3892 + } + }, + { + "name": "ImGui_InputTextWithHintAndSize", + "original_fully_qualified_name": "ImGui::InputTextEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hint", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_arg", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// InputText" + ], + "attached": "// Implied callback = NULL, user_data = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3895 + } + }, + { + "name": "ImGui_InputTextWithHintAndSizeEx", + "original_fully_qualified_name": "ImGui::InputTextEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hint", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_arg", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "callback", + "type": { + "declaration": "ImGuiInputTextCallback", + "description": { + "kind": "User", + "name": "ImGuiInputTextCallback" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3895 + } + }, + { + "name": "ImGui_InputTextDeactivateHook", + "original_fully_qualified_name": "ImGui::InputTextDeactivateHook", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3896 + } + }, + { + "name": "ImGui_TempInputText", + "original_fully_qualified_name": "ImGui::TempInputText", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3897 + } + }, + { + "name": "ImGui_TempInputScalar", + "original_fully_qualified_name": "ImGui::TempInputScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied p_clamp_min = NULL, p_clamp_max = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3898 + } + }, + { + "name": "ImGui_TempInputScalarEx", + "original_fully_qualified_name": "ImGui::TempInputScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_clamp_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "p_clamp_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3898 + } + }, + { + "name": "ImGui_TempInputIsActive", + "original_fully_qualified_name": "ImGui::TempInputIsActive", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3899 + } + }, + { + "name": "ImGui_SetNextItemRefVal", + "original_fully_qualified_name": "ImGui::SetNextItemRefVal", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3901 + } + }, + { + "name": "ImGui_IsItemActiveAsInputText", + "original_fully_qualified_name": "ImGui::IsItemActiveAsInputText", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// This may be useful to apply workaround that a based on distinguish whenever an item is active as a text input field." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3902 + } + }, + { + "name": "ImGui_ColorTooltip", + "original_fully_qualified_name": "ImGui::ColorTooltip", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Color" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3905 + } + }, + { + "name": "ImGui_ColorEditOptionsPopup", + "original_fully_qualified_name": "ImGui::ColorEditOptionsPopup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3906 + } + }, + { + "name": "ImGui_ColorPickerOptionsPopup", + "original_fully_qualified_name": "ImGui::ColorPickerOptionsPopup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ref_col", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3907 + } + }, + { + "name": "ImGui_PlotEx", + "original_fully_qualified_name": "ImGui::PlotEx", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "plot_type", + "type": { + "declaration": "ImGuiPlotType", + "description": { + "kind": "User", + "name": "ImGuiPlotType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_getter", + "type": { + "declaration": "float (*values_getter)(void* data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "values_getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "float" + }, + "parameters": [ + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_offset", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "overlay_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scale_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "scale_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_arg", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Plot" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3910 + } + }, + { + "name": "ImGui_ShadeVertsLinearColorGradientKeepAlpha", + "original_fully_qualified_name": "ImGui::ShadeVertsLinearColorGradientKeepAlpha", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vert_start_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vert_end_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "gradient_p0", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "gradient_p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col0", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col1", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Shade functions (write over already created vertices)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3913 + } + }, + { + "name": "ImGui_ShadeVertsLinearUV", + "original_fully_qualified_name": "ImGui::ShadeVertsLinearUV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vert_start_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vert_end_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clamp", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3914 + } + }, + { + "name": "ImGui_ShadeVertsTransformPos", + "original_fully_qualified_name": "ImGui::ShadeVertsTransformPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vert_start_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vert_end_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pivot_in", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cos_a", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sin_a", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pivot_out", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3915 + } + }, + { + "name": "ImGui_GcCompactTransientMiscBuffers", + "original_fully_qualified_name": "ImGui::GcCompactTransientMiscBuffers", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Garbage collection" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3918 + } + }, + { + "name": "ImGui_GcCompactTransientWindowBuffers", + "original_fully_qualified_name": "ImGui::GcCompactTransientWindowBuffers", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3919 + } + }, + { + "name": "ImGui_GcAwakeTransientWindowBuffers", + "original_fully_qualified_name": "ImGui::GcAwakeTransientWindowBuffers", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3920 + } + }, + { + "name": "ImGui_ErrorLog", + "original_fully_qualified_name": "ImGui::ErrorLog", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "msg", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Error handling, State Recovery" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3923 + } + }, + { + "name": "ImGui_ErrorRecoveryStoreState", + "original_fully_qualified_name": "ImGui::ErrorRecoveryStoreState", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "state_out", + "type": { + "declaration": "ImGuiErrorRecoveryState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiErrorRecoveryState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3924 + } + }, + { + "name": "ImGui_ErrorRecoveryTryToRecoverState", + "original_fully_qualified_name": "ImGui::ErrorRecoveryTryToRecoverState", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "state_in", + "type": { + "declaration": "const ImGuiErrorRecoveryState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiErrorRecoveryState", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3925 + } + }, + { + "name": "ImGui_ErrorRecoveryTryToRecoverWindowState", + "original_fully_qualified_name": "ImGui::ErrorRecoveryTryToRecoverWindowState", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "state_in", + "type": { + "declaration": "const ImGuiErrorRecoveryState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiErrorRecoveryState", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3926 + } + }, + { + "name": "ImGui_ErrorCheckUsingSetCursorPosToExtendParentBoundaries", + "original_fully_qualified_name": "ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3927 + } + }, + { + "name": "ImGui_ErrorCheckEndFrameFinalizeErrorTooltip", + "original_fully_qualified_name": "ImGui::ErrorCheckEndFrameFinalizeErrorTooltip", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3928 + } + }, + { + "name": "ImGui_BeginErrorTooltip", + "original_fully_qualified_name": "ImGui::BeginErrorTooltip", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3929 + } + }, + { + "name": "ImGui_EndErrorTooltip", + "original_fully_qualified_name": "ImGui::EndErrorTooltip", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3930 + } + }, + { + "name": "ImGui_DebugAllocHook", + "original_fully_qualified_name": "ImGui::DebugAllocHook", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "info", + "type": { + "declaration": "ImGuiDebugAllocInfo*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDebugAllocInfo" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "frame_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "ptr", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Debug Tools" + ], + "attached": "// size >= 0 : alloc, size = -1 : free" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3933 + } + }, + { + "name": "ImGui_DebugDrawCursorPos", + "original_fully_qualified_name": "ImGui::DebugDrawCursorPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied col = IM_COL32(255, 0, 0, 255)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3934 + } + }, + { + "name": "ImGui_DebugDrawCursorPosEx", + "original_fully_qualified_name": "ImGui::DebugDrawCursorPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "IM_COL32(255, 0, 0, 255)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3934 + } + }, + { + "name": "ImGui_DebugDrawLineExtents", + "original_fully_qualified_name": "ImGui::DebugDrawLineExtents", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied col = IM_COL32(255, 0, 0, 255)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3935 + } + }, + { + "name": "ImGui_DebugDrawLineExtentsEx", + "original_fully_qualified_name": "ImGui::DebugDrawLineExtents", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "IM_COL32(255, 0, 0, 255)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3935 + } + }, + { + "name": "ImGui_DebugDrawItemRect", + "original_fully_qualified_name": "ImGui::DebugDrawItemRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied col = IM_COL32(255, 0, 0, 255)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3936 + } + }, + { + "name": "ImGui_DebugDrawItemRectEx", + "original_fully_qualified_name": "ImGui::DebugDrawItemRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "IM_COL32(255, 0, 0, 255)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3936 + } + }, + { + "name": "ImGui_DebugTextUnformattedWithLocateItem", + "original_fully_qualified_name": "ImGui::DebugTextUnformattedWithLocateItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "line_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "line_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3937 + } + }, + { + "name": "ImGui_DebugLocateItem", + "original_fully_qualified_name": "ImGui::DebugLocateItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "target_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Call sparingly: only 1 at the same time!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3938 + } + }, + { + "name": "ImGui_DebugLocateItemOnHover", + "original_fully_qualified_name": "ImGui::DebugLocateItemOnHover", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "target_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Only call on reaction to a mouse Hover: because only 1 at the same time!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3939 + } + }, + { + "name": "ImGui_DebugLocateItemResolveWithLastItem", + "original_fully_qualified_name": "ImGui::DebugLocateItemResolveWithLastItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3940 + } + }, + { + "name": "ImGui_DebugBreakClearData", + "original_fully_qualified_name": "ImGui::DebugBreakClearData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3941 + } + }, + { + "name": "ImGui_DebugBreakButton", + "original_fully_qualified_name": "ImGui::DebugBreakButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "description_of_location", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3942 + } + }, + { + "name": "ImGui_DebugBreakButtonTooltip", + "original_fully_qualified_name": "ImGui::DebugBreakButtonTooltip", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "keyboard_only", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "description_of_location", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3943 + } + }, + { + "name": "ImGui_ShowFontAtlas", + "original_fully_qualified_name": "ImGui::ShowFontAtlas", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3944 + } + }, + { + "name": "ImGui_DebugHookIdInfo", + "original_fully_qualified_name": "ImGui::DebugHookIdInfo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_id_end", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3945 + } + }, + { + "name": "ImGui_DebugNodeColumns", + "original_fully_qualified_name": "ImGui::DebugNodeColumns", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "columns", + "type": { + "declaration": "ImGuiOldColumns*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiOldColumns" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3946 + } + }, + { + "name": "ImGui_DebugNodeDockNode", + "original_fully_qualified_name": "ImGui::DebugNodeDockNode", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "node", + "type": { + "declaration": "ImGuiDockNode*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiDockNode" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3947 + } + }, + { + "name": "ImGui_DebugNodeDrawList", + "original_fully_qualified_name": "ImGui::DebugNodeDrawList", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "draw_list", + "type": { + "declaration": "const ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3948 + } + }, + { + "name": "ImGui_DebugNodeDrawCmdShowMeshAndBoundingBox", + "original_fully_qualified_name": "ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "out_draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "draw_list", + "type": { + "declaration": "const ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "draw_cmd", + "type": { + "declaration": "const ImDrawCmd*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawCmd", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "show_mesh", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "show_aabb", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3949 + } + }, + { + "name": "ImGui_DebugNodeFont", + "original_fully_qualified_name": "ImGui::DebugNodeFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3950 + } + }, + { + "name": "ImGui_DebugNodeFontGlyphesForSrcMask", + "original_fully_qualified_name": "ImGui::DebugNodeFontGlyphesForSrcMask", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_mask", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3951 + } + }, + { + "name": "ImGui_DebugNodeFontGlyph", + "original_fully_qualified_name": "ImGui::DebugNodeFontGlyph", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "glyph", + "type": { + "declaration": "const ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3952 + } + }, + { + "name": "ImGui_DebugNodeTexture", + "original_fully_qualified_name": "ImGui::DebugNodeTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "int_id", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied highlight_rect = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3953 + } + }, + { + "name": "ImGui_DebugNodeTextureEx", + "original_fully_qualified_name": "ImGui::DebugNodeTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "int_id", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "highlight_rect", + "type": { + "declaration": "const ImFontAtlasRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ID used to facilitate persisting the \"current\" texture." + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3953 + } + }, + { + "name": "ImGui_DebugNodeStorage", + "original_fully_qualified_name": "ImGui::DebugNodeStorage", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "storage", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3954 + } + }, + { + "name": "ImGui_DebugNodeTabBar", + "original_fully_qualified_name": "ImGui::DebugNodeTabBar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_bar", + "type": { + "declaration": "ImGuiTabBar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTabBar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3955 + } + }, + { + "name": "ImGui_DebugNodeTable", + "original_fully_qualified_name": "ImGui::DebugNodeTable", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "table", + "type": { + "declaration": "ImGuiTable*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTable" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3956 + } + }, + { + "name": "ImGui_DebugNodeTableSettings", + "original_fully_qualified_name": "ImGui::DebugNodeTableSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "settings", + "type": { + "declaration": "ImGuiTableSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableSettings" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3957 + } + }, + { + "name": "ImGui_DebugNodeTypingSelectState", + "original_fully_qualified_name": "ImGui::DebugNodeTypingSelectState", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "state", + "type": { + "declaration": "ImGuiTypingSelectState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTypingSelectState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3959 + } + }, + { + "name": "ImGui_DebugNodeMultiSelectState", + "original_fully_qualified_name": "ImGui::DebugNodeMultiSelectState", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "state", + "type": { + "declaration": "ImGuiMultiSelectState*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectState" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3960 + } + }, + { + "name": "ImGui_DebugNodeWindow", + "original_fully_qualified_name": "ImGui::DebugNodeWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3961 + } + }, + { + "name": "ImGui_DebugNodeWindowSettings", + "original_fully_qualified_name": "ImGui::DebugNodeWindowSettings", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "settings", + "type": { + "declaration": "ImGuiWindowSettings*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowSettings" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3962 + } + }, + { + "name": "ImGui_DebugNodeWindowsList", + "original_fully_qualified_name": "ImGui::DebugNodeWindowsList", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "windows", + "type": { + "declaration": "ImVector_ImGuiWindowPtr*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_ImGuiWindowPtr" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3963 + } + }, + { + "name": "ImGui_DebugNodeWindowsListByBeginStackParent", + "original_fully_qualified_name": "ImGui::DebugNodeWindowsListByBeginStackParent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "windows", + "type": { + "declaration": "ImGuiWindow**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "windows_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "parent_in_begin_stack", + "type": { + "declaration": "ImGuiWindow*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindow" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3964 + } + }, + { + "name": "ImGui_DebugNodeViewport", + "original_fully_qualified_name": "ImGui::DebugNodeViewport", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3965 + } + }, + { + "name": "ImGui_DebugNodePlatformMonitor", + "original_fully_qualified_name": "ImGui::DebugNodePlatformMonitor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "monitor", + "type": { + "declaration": "ImGuiPlatformMonitor*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPlatformMonitor" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3966 + } + }, + { + "name": "ImGui_DebugRenderKeyboardPreview", + "original_fully_qualified_name": "ImGui::DebugRenderKeyboardPreview", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3967 + } + }, + { + "name": "ImGui_DebugRenderViewportThumbnail", + "original_fully_qualified_name": "ImGui::DebugRenderViewportThumbnail", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewportP*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewportP" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 3968 + } + }, + { + "name": "cImFontAtlasGetFontLoaderForStbTruetype", + "original_fully_qualified_name": "ImFontAtlasGetFontLoaderForStbTruetype", + "return_type": { + "declaration": "const ImFontLoader*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontLoader", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_STB_TRUETYPE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4014 + } + }, + { + "name": "cImFontAtlasRectId_GetIndex", + "original_fully_qualified_name": "ImFontAtlasRectId_GetIndex", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4036 + } + }, + { + "name": "cImFontAtlasRectId_GetGeneration", + "original_fully_qualified_name": "ImFontAtlasRectId_GetGeneration", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4037 + } + }, + { + "name": "cImFontAtlasRectId_Make", + "original_fully_qualified_name": "ImFontAtlasRectId_Make", + "return_type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "arguments": [ + { + "name": "index_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "gen_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4038 + } + }, + { + "name": "cImFontAtlasBuildInit", + "original_fully_qualified_name": "ImFontAtlasBuildInit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4110 + } + }, + { + "name": "cImFontAtlasBuildDestroy", + "original_fully_qualified_name": "ImFontAtlasBuildDestroy", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4111 + } + }, + { + "name": "cImFontAtlasBuildMain", + "original_fully_qualified_name": "ImFontAtlasBuildMain", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4112 + } + }, + { + "name": "cImFontAtlasBuildSetupFontLoader", + "original_fully_qualified_name": "ImFontAtlasBuildSetupFontLoader", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_loader", + "type": { + "declaration": "const ImFontLoader*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontLoader", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4113 + } + }, + { + "name": "cImFontAtlasBuildUpdatePointers", + "original_fully_qualified_name": "ImFontAtlasBuildUpdatePointers", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4114 + } + }, + { + "name": "cImFontAtlasBuildRenderBitmapFromString", + "original_fully_qualified_name": "ImFontAtlasBuildRenderBitmapFromString", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "x", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "y", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_marker_char", + "type": { + "declaration": "char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4115 + } + }, + { + "name": "cImFontAtlasBuildClear", + "original_fully_qualified_name": "ImFontAtlasBuildClear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Clear output and custom rects" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4116 + } + }, + { + "name": "cImFontAtlasTextureAdd", + "original_fully_qualified_name": "ImFontAtlasTextureAdd", + "return_type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4118 + } + }, + { + "name": "cImFontAtlasTextureMakeSpace", + "original_fully_qualified_name": "ImFontAtlasTextureMakeSpace", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4119 + } + }, + { + "name": "cImFontAtlasTextureRepack", + "original_fully_qualified_name": "ImFontAtlasTextureRepack", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4120 + } + }, + { + "name": "cImFontAtlasTextureGrow", + "original_fully_qualified_name": "ImFontAtlasTextureGrow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied old_w = -1, old_h = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4121 + } + }, + { + "name": "cImFontAtlasTextureGrowEx", + "original_fully_qualified_name": "ImFontAtlasTextureGrow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + }, + { + "name": "old_h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4121 + } + }, + { + "name": "cImFontAtlasTextureCompact", + "original_fully_qualified_name": "ImFontAtlasTextureCompact", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4122 + } + }, + { + "name": "cImFontAtlasTextureGetSizeEstimate", + "original_fully_qualified_name": "ImFontAtlasTextureGetSizeEstimate", + "return_type": { + "declaration": "ImVec2i", + "description": { + "kind": "User", + "name": "ImVec2i" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4123 + } + }, + { + "name": "cImFontAtlasBuildSetupFontSpecialGlyphs", + "original_fully_qualified_name": "ImFontAtlasBuildSetupFontSpecialGlyphs", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4125 + } + }, + { + "name": "cImFontAtlasBuildLegacyPreloadAllGlyphRanges", + "original_fully_qualified_name": "ImFontAtlasBuildLegacyPreloadAllGlyphRanges", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Legacy" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4126 + } + }, + { + "name": "cImFontAtlasBuildGetOversampleFactors", + "original_fully_qualified_name": "ImFontAtlasBuildGetOversampleFactors", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_oversample_h", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_oversample_v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4127 + } + }, + { + "name": "cImFontAtlasBuildDiscardBakes", + "original_fully_qualified_name": "ImFontAtlasBuildDiscardBakes", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "unused_frames", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4128 + } + }, + { + "name": "cImFontAtlasFontSourceInit", + "original_fully_qualified_name": "ImFontAtlasFontSourceInit", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4130 + } + }, + { + "name": "cImFontAtlasFontSourceAddToFont", + "original_fully_qualified_name": "ImFontAtlasFontSourceAddToFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4131 + } + }, + { + "name": "cImFontAtlasFontDestroySourceData", + "original_fully_qualified_name": "ImFontAtlasFontDestroySourceData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4132 + } + }, + { + "name": "cImFontAtlasFontInitOutput", + "original_fully_qualified_name": "ImFontAtlasFontInitOutput", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Using FontDestroyOutput/FontInitOutput sequence useful notably if font loader params have changed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4133 + } + }, + { + "name": "cImFontAtlasFontDestroyOutput", + "original_fully_qualified_name": "ImFontAtlasFontDestroyOutput", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4134 + } + }, + { + "name": "cImFontAtlasFontDiscardBakes", + "original_fully_qualified_name": "ImFontAtlasFontDiscardBakes", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "unused_frames", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4135 + } + }, + { + "name": "cImFontAtlasBakedGetId", + "original_fully_qualified_name": "ImFontAtlasBakedGetId", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "font_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rasterizer_density", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4137 + } + }, + { + "name": "cImFontAtlasBakedGetOrAdd", + "original_fully_qualified_name": "ImFontAtlasBakedGetOrAdd", + "return_type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_rasterizer_density", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4138 + } + }, + { + "name": "cImFontAtlasBakedGetClosestMatch", + "original_fully_qualified_name": "ImFontAtlasBakedGetClosestMatch", + "return_type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_rasterizer_density", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4139 + } + }, + { + "name": "cImFontAtlasBakedAdd", + "original_fully_qualified_name": "ImFontAtlasBakedAdd", + "return_type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_rasterizer_density", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4140 + } + }, + { + "name": "cImFontAtlasBakedDiscard", + "original_fully_qualified_name": "ImFontAtlasBakedDiscard", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4141 + } + }, + { + "name": "cImFontAtlasBakedAddFontGlyph", + "original_fully_qualified_name": "ImFontAtlasBakedAddFontGlyph", + "return_type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "in_glyph", + "type": { + "declaration": "const ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4142 + } + }, + { + "name": "cImFontAtlasBakedAddFontGlyphAdvancedX", + "original_fully_qualified_name": "ImFontAtlasBakedAddFontGlyphAdvancedX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "codepoint", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "advance_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4143 + } + }, + { + "name": "cImFontAtlasBakedDiscardFontGlyph", + "original_fully_qualified_name": "ImFontAtlasBakedDiscardFontGlyph", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "glyph", + "type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4144 + } + }, + { + "name": "cImFontAtlasBakedSetFontGlyphBitmap", + "original_fully_qualified_name": "ImFontAtlasBakedSetFontGlyphBitmap", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "baked", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src", + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "glyph", + "type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r", + "type": { + "declaration": "ImTextureRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_pixels", + "type": { + "declaration": "const unsigned char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_fmt", + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_pitch", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4145 + } + }, + { + "name": "cImFontAtlasPackInit", + "original_fully_qualified_name": "ImFontAtlasPackInit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4147 + } + }, + { + "name": "cImFontAtlasPackAddRect", + "original_fully_qualified_name": "ImFontAtlasPackAddRect", + "return_type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied overwrite_entry = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4148 + } + }, + { + "name": "cImFontAtlasPackAddRectEx", + "original_fully_qualified_name": "ImFontAtlasPackAddRect", + "return_type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "overwrite_entry", + "type": { + "declaration": "ImFontAtlasRectEntry*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasRectEntry" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4148 + } + }, + { + "name": "cImFontAtlasPackGetRect", + "original_fully_qualified_name": "ImFontAtlasPackGetRect", + "return_type": { + "declaration": "ImTextureRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureRect" + } + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4149 + } + }, + { + "name": "cImFontAtlasPackGetRectSafe", + "original_fully_qualified_name": "ImFontAtlasPackGetRectSafe", + "return_type": { + "declaration": "ImTextureRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureRect" + } + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4150 + } + }, + { + "name": "cImFontAtlasPackDiscardRect", + "original_fully_qualified_name": "ImFontAtlasPackDiscardRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4151 + } + }, + { + "name": "cImFontAtlasUpdateNewFrame", + "original_fully_qualified_name": "ImFontAtlasUpdateNewFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "frame_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "renderer_has_textures", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4153 + } + }, + { + "name": "cImFontAtlasAddDrawListSharedData", + "original_fully_qualified_name": "ImFontAtlasAddDrawListSharedData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "ImDrawListSharedData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawListSharedData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4154 + } + }, + { + "name": "cImFontAtlasRemoveDrawListSharedData", + "original_fully_qualified_name": "ImFontAtlasRemoveDrawListSharedData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "ImDrawListSharedData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawListSharedData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4155 + } + }, + { + "name": "cImFontAtlasUpdateDrawListsTextures", + "original_fully_qualified_name": "ImFontAtlasUpdateDrawListsTextures", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_tex", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "new_tex", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4156 + } + }, + { + "name": "cImFontAtlasUpdateDrawListsSharedData", + "original_fully_qualified_name": "ImFontAtlasUpdateDrawListsSharedData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4157 + } + }, + { + "name": "cImFontAtlasTextureBlockConvert", + "original_fully_qualified_name": "ImFontAtlasTextureBlockConvert", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "src_pixels", + "type": { + "declaration": "const unsigned char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_fmt", + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_pitch", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_pixels", + "type": { + "declaration": "unsigned char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_fmt", + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_pitch", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4159 + } + }, + { + "name": "cImFontAtlasTextureBlockPostProcess", + "original_fully_qualified_name": "ImFontAtlasTextureBlockPostProcess", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "ImFontAtlasPostProcessData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasPostProcessData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4160 + } + }, + { + "name": "cImFontAtlasTextureBlockPostProcessMultiply", + "original_fully_qualified_name": "ImFontAtlasTextureBlockPostProcessMultiply", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "ImFontAtlasPostProcessData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasPostProcessData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "multiply_factor", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4161 + } + }, + { + "name": "cImFontAtlasTextureBlockFill", + "original_fully_qualified_name": "ImFontAtlasTextureBlockFill", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "dst_tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_x", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_y", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4162 + } + }, + { + "name": "cImFontAtlasTextureBlockCopy", + "original_fully_qualified_name": "ImFontAtlasTextureBlockCopy", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "src_tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_x", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "src_y", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_x", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dst_y", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4163 + } + }, + { + "name": "cImFontAtlasTextureBlockQueueUpload", + "original_fully_qualified_name": "ImFontAtlasTextureBlockQueueUpload", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tex", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "x", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "y", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4164 + } + }, + { + "name": "cImTextureDataGetFormatBytesPerPixel", + "original_fully_qualified_name": "ImTextureDataGetFormatBytesPerPixel", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "format", + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4166 + } + }, + { + "name": "cImTextureDataGetStatusName", + "original_fully_qualified_name": "ImTextureDataGetStatusName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "status", + "type": { + "declaration": "ImTextureStatus", + "description": { + "kind": "User", + "name": "ImTextureStatus" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4167 + } + }, + { + "name": "cImTextureDataGetFormatName", + "original_fully_qualified_name": "ImTextureDataGetFormatName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "format", + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4168 + } + }, + { + "name": "cImFontAtlasDebugLogTextureRequests", + "original_fully_qualified_name": "ImFontAtlasDebugLogTextureRequests", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEBUG_TOOLS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4171 + } + }, + { + "name": "cImFontAtlasGetMouseCursorTexData", + "original_fully_qualified_name": "ImFontAtlasGetMouseCursorTexData", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cursor_type", + "type": { + "declaration": "ImGuiMouseCursor", + "description": { + "kind": "User", + "name": "ImGuiMouseCursor" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_offset", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_size", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_uv_border", + "type": { + "declaration": "ImVec2[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "out_uv_fill", + "type": { + "declaration": "ImVec2[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4174 + } + }, + { + "name": "cImGuiTestEngineHook_ItemAdd", + "original_fully_qualified_name": "ImGuiTestEngineHook_ItemAdd", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bb", + "type": { + "declaration": "ImRect", + "description": { + "kind": "User", + "name": "ImRect" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "item_data", + "type": { + "declaration": "const ImGuiLastItemData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiLastItemData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// item_data may be NULL" + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4181 + } + }, + { + "name": "cImGuiTestEngineHook_ItemInfo", + "original_fully_qualified_name": "ImGuiTestEngineHook_ItemInfo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiItemStatusFlags", + "description": { + "kind": "User", + "name": "ImGuiItemStatusFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4182 + } + }, + { + "name": "cImGuiTestEngineHook_Log", + "original_fully_qualified_name": "ImGuiTestEngineHook_Log", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "__unnamed_arg2__", + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4183 + } + }, + { + "name": "cImGuiTestEngine_FindItemDebugLabel", + "original_fully_qualified_name": "ImGuiTestEngine_FindItemDebugLabel", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_ENABLE_TEST_ENGINE" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui_internal.h", + "line": 4184 + } + } + ] +} \ No newline at end of file diff --git a/src/cached/dcimgui_internal_imconfig.json b/src/cached/dcimgui_internal_imconfig.json new file mode 100644 index 0000000..c284c5c --- /dev/null +++ b/src/cached/dcimgui_internal_imconfig.json @@ -0,0 +1,7 @@ +{ + "defines": [], + "enums": [], + "typedefs": [], + "structs": [], + "functions": [] +} \ No newline at end of file diff --git a/src/cached/dcimgui_internal_imgui.json b/src/cached/dcimgui_internal_imgui.json new file mode 100644 index 0000000..22dc763 --- /dev/null +++ b/src/cached/dcimgui_internal_imgui.json @@ -0,0 +1,78535 @@ +{ + "defines": [ + { + "name": "IMGUI_VERSION", + "content": "\"1.92.2b\"", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 31 + } + }, + { + "name": "IMGUI_VERSION_NUM", + "content": "19222", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 32 + } + }, + { + "name": "IMGUI_HAS_TABLE", + "comments": { + "attached": "// Added BeginTable() - from IMGUI_VERSION_NUM >= 18000" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 33 + } + }, + { + "name": "IMGUI_HAS_TEXTURES", + "comments": { + "attached": "// Added ImGuiBackendFlags_RendererHasTextures - from IMGUI_VERSION_NUM >= 19198" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 34 + } + }, + { + "name": "IMGUI_HAS_VIEWPORT", + "comments": { + "attached": "// In 'docking' WIP branch." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 35 + } + }, + { + "name": "IMGUI_HAS_DOCK", + "comments": { + "attached": "// In 'docking' WIP branch." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 36 + } + }, + { + "name": "IMGUI_DEAR_BINDINGS_HAS_GETWINDOWFRAMEBUFFERSCALE", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "IMGUI_DEAR_BINDINGS_HAS_GETWINDOWWORKAREAINSETS", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "IMGUI_API", + "conditionals": [ + { + "condition": "ifndef", + "expression": "CIMGUI_API" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 87 + } + }, + { + "name": "IMGUI_IMPL_API", + "content": "IMGUI_API", + "conditionals": [ + { + "condition": "ifndef", + "expression": "CIMGUI_IMPL_API" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 90 + } + }, + { + "name": "IM_MSVC_RUNTIME_CHECKS_OFF", + "content": "__pragma(runtime_checks(\"\",off)) __pragma(check_stack(off)) __pragma(strict_gs_check(push,off))", + "conditionals": [ + { + "condition": "if", + "expression": "defined(_MSC_VER)&&!defined(__clang__)&&!defined(__INTEL_COMPILER)&&!defined(IMGUI_DEBUG_PARANOID)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 120 + } + }, + { + "name": "IM_MSVC_RUNTIME_CHECKS_RESTORE", + "content": "__pragma(runtime_checks(\"\",restore)) __pragma(check_stack()) __pragma(strict_gs_check(pop))", + "conditionals": [ + { + "condition": "if", + "expression": "defined(_MSC_VER)&&!defined(__clang__)&&!defined(__INTEL_COMPILER)&&!defined(IMGUI_DEBUG_PARANOID)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 121 + } + }, + { + "name": "IM_MSVC_RUNTIME_CHECKS_OFF", + "conditionals": [ + { + "condition": "ifnot", + "expression": "defined(_MSC_VER)&&!defined(__clang__)&&!defined(__INTEL_COMPILER)&&!defined(IMGUI_DEBUG_PARANOID)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 123 + } + }, + { + "name": "IM_MSVC_RUNTIME_CHECKS_RESTORE", + "conditionals": [ + { + "condition": "ifnot", + "expression": "defined(_MSC_VER)&&!defined(__clang__)&&!defined(__INTEL_COMPILER)&&!defined(IMGUI_DEBUG_PARANOID)" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 124 + } + }, + { + "name": "ImTextureID_Invalid", + "content": "(ImTextureID)0", + "conditionals": [ + { + "condition": "ifndef", + "expression": "ImTextureID_Invalid" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 342 + } + }, + { + "name": "IMGUI_PAYLOAD_TYPE_COLOR_3F", + "content": "\"_COL3F\"", + "comments": { + "attached": "// float[3]: Standard type for colors, without alpha. User code may use this type." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1538 + } + }, + { + "name": "IMGUI_PAYLOAD_TYPE_COLOR_4F", + "content": "\"_COL4F\"", + "comments": { + "attached": "// float[4]: Standard type for colors. User code may use this type." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1539 + } + }, + { + "name": "IM_UNICODE_CODEPOINT_INVALID", + "content": "0xFFFD", + "comments": { + "attached": "// Invalid Unicode code point (standard value)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2785 + } + }, + { + "name": "IM_UNICODE_CODEPOINT_MAX", + "content": "0x10FFFF", + "comments": { + "attached": "// Maximum Unicode code point supported by this build." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_USE_WCHAR32" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2787 + } + }, + { + "name": "IM_UNICODE_CODEPOINT_MAX", + "content": "0xFFFF", + "comments": { + "attached": "// Maximum Unicode code point supported by this build." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_USE_WCHAR32" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2789 + } + }, + { + "name": "IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED", + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DEFINE_MATH_OPERATORS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2966 + } + }, + { + "name": "IM_COL32_R_SHIFT", + "content": "16", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifdef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3002 + } + }, + { + "name": "IM_COL32_G_SHIFT", + "content": "8", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifdef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3003 + } + }, + { + "name": "IM_COL32_B_SHIFT", + "content": "0", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifdef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3004 + } + }, + { + "name": "IM_COL32_A_SHIFT", + "content": "24", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifdef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3005 + } + }, + { + "name": "IM_COL32_A_MASK", + "content": "0xFF000000", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifdef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3006 + } + }, + { + "name": "IM_COL32_R_SHIFT", + "content": "0", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifndef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3008 + } + }, + { + "name": "IM_COL32_G_SHIFT", + "content": "8", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifndef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3009 + } + }, + { + "name": "IM_COL32_B_SHIFT", + "content": "16", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifndef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3010 + } + }, + { + "name": "IM_COL32_A_SHIFT", + "content": "24", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifndef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3011 + } + }, + { + "name": "IM_COL32_A_MASK", + "content": "0xFF000000", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_COL32_R_SHIFT" + }, + { + "condition": "ifndef", + "expression": "IMGUI_USE_BGRA_PACKED_COLOR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3012 + } + }, + { + "name": "IM_DRAWLIST_TEX_LINES_WIDTH_MAX", + "content": "32", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IM_DRAWLIST_TEX_LINES_WIDTH_MAX" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3196 + } + }, + { + "name": "ImFontAtlasRectId_Invalid", + "content": "-1", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3673 + } + } + ], + "enums": [ + { + "name": "ImGuiWindowFlags_", + "original_fully_qualified_name": "ImGuiWindowFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiWindowFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1183 + } + }, + { + "name": "ImGuiWindowFlags_NoTitleBar", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Disable title-bar" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1184 + } + }, + { + "name": "ImGuiWindowFlags_NoResize", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Disable user resizing with the lower-right grip" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1185 + } + }, + { + "name": "ImGuiWindowFlags_NoMove", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Disable user moving the window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1186 + } + }, + { + "name": "ImGuiWindowFlags_NoScrollbar", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Disable scrollbars (window can still scroll with mouse or programmatically)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1187 + } + }, + { + "name": "ImGuiWindowFlags_NoScrollWithMouse", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Disable user vertically scrolling with mouse wheel. On child window, mouse wheel will be forwarded to the parent unless NoScrollbar is also set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1188 + } + }, + { + "name": "ImGuiWindowFlags_NoCollapse", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Disable user collapsing window by double-clicking on it. Also referred to as Window Menu Button (e.g. within a docking node)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1189 + } + }, + { + "name": "ImGuiWindowFlags_AlwaysAutoResize", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Resize every window to its content every frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1190 + } + }, + { + "name": "ImGuiWindowFlags_NoBackground", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Disable drawing background color (WindowBg, etc.) and outside border. Similar as using SetNextWindowBgAlpha(0.0f)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1191 + } + }, + { + "name": "ImGuiWindowFlags_NoSavedSettings", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Never load/save settings in .ini file" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1192 + } + }, + { + "name": "ImGuiWindowFlags_NoMouseInputs", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Disable catching mouse, hovering test with pass through." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1193 + } + }, + { + "name": "ImGuiWindowFlags_MenuBar", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Has a menu-bar" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1194 + } + }, + { + "name": "ImGuiWindowFlags_HorizontalScrollbar", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(ImVec2(width,0.0f)); prior to calling Begin() to specify width. Read code in imgui_demo in the \"Horizontal Scrolling\" section." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1195 + } + }, + { + "name": "ImGuiWindowFlags_NoFocusOnAppearing", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Disable taking focus when transitioning from hidden to visible state" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1196 + } + }, + { + "name": "ImGuiWindowFlags_NoBringToFrontOnFocus", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Disable bringing window to front when taking focus (e.g. clicking on it or programmatically giving it focus)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1197 + } + }, + { + "name": "ImGuiWindowFlags_AlwaysVerticalScrollbar", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Always show vertical scrollbar (even if ContentSize.y < Size.y)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1198 + } + }, + { + "name": "ImGuiWindowFlags_AlwaysHorizontalScrollbar", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Always show horizontal scrollbar (even if ContentSize.x < Size.x)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1199 + } + }, + { + "name": "ImGuiWindowFlags_NoNavInputs", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// No keyboard/gamepad navigation within the window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1200 + } + }, + { + "name": "ImGuiWindowFlags_NoNavFocus", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// No focusing toward this window with keyboard/gamepad navigation (e.g. skipped by CTRL+TAB)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1201 + } + }, + { + "name": "ImGuiWindowFlags_UnsavedDocument", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "attached": "// Display a dot next to the title. When used in a tab/docking context, tab is selected when clicking the X + closure is not assumed (will wait for user to stop submitting the tab). Otherwise closure is assumed when pressing the X, so if you keep submitting the tab may reappear at end of tab bar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1202 + } + }, + { + "name": "ImGuiWindowFlags_NoDocking", + "value_expression": "1<<19", + "value": 524288, + "is_count": false, + "comments": { + "attached": "// Disable docking of this window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1203 + } + }, + { + "name": "ImGuiWindowFlags_NoNav", + "value_expression": "ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus", + "value": 196608, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1204 + } + }, + { + "name": "ImGuiWindowFlags_NoDecoration", + "value_expression": "ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse", + "value": 43, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1205 + } + }, + { + "name": "ImGuiWindowFlags_NoInputs", + "value_expression": "ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus", + "value": 197120, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1206 + } + }, + { + "name": "ImGuiWindowFlags_DockNodeHost", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal]" + ], + "attached": "// Don't use! For internal use by Begin()/NewFrame()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1209 + } + }, + { + "name": "ImGuiWindowFlags_ChildWindow", + "value_expression": "1<<24", + "value": 16777216, + "is_count": false, + "comments": { + "attached": "// Don't use! For internal use by BeginChild()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1210 + } + }, + { + "name": "ImGuiWindowFlags_Tooltip", + "value_expression": "1<<25", + "value": 33554432, + "is_count": false, + "comments": { + "attached": "// Don't use! For internal use by BeginTooltip()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1211 + } + }, + { + "name": "ImGuiWindowFlags_Popup", + "value_expression": "1<<26", + "value": 67108864, + "is_count": false, + "comments": { + "attached": "// Don't use! For internal use by BeginPopup()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1212 + } + }, + { + "name": "ImGuiWindowFlags_Modal", + "value_expression": "1<<27", + "value": 134217728, + "is_count": false, + "comments": { + "attached": "// Don't use! For internal use by BeginPopupModal()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1213 + } + }, + { + "name": "ImGuiWindowFlags_ChildMenu", + "value_expression": "1<<28", + "value": 268435456, + "is_count": false, + "comments": { + "attached": "// Don't use! For internal use by BeginMenu()" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1214 + } + }, + { + "name": "ImGuiWindowFlags_NavFlattened", + "value_expression": "1<<29", + "value": 536870912, + "is_count": false, + "comments": { + "attached": "// Obsoleted in 1.90.9: Use ImGuiChildFlags_NavFlattened in BeginChild() call." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1218 + } + }, + { + "name": "ImGuiWindowFlags_AlwaysUseWindowPadding", + "value_expression": "1<<30", + "value": 1073741824, + "is_count": false, + "comments": { + "attached": "// Obsoleted in 1.90.0: Use ImGuiChildFlags_AlwaysUseWindowPadding in BeginChild() call." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1219 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::Begin()", + "// (Those are per-window flags. There are shared flags in ImGuiIO: io.ConfigWindowsResizeFromEdges and io.ConfigWindowsMoveFromTitleBarOnly)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1181 + } + }, + { + "name": "ImGuiChildFlags_", + "original_fully_qualified_name": "ImGuiChildFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiChildFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1234 + } + }, + { + "name": "ImGuiChildFlags_Borders", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Show an outer border and enable WindowPadding. (IMPORTANT: this is always == 1 == true for legacy reason)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1235 + } + }, + { + "name": "ImGuiChildFlags_AlwaysUseWindowPadding", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Pad with style.WindowPadding even if no border are drawn (no padding by default for non-bordered child windows because it makes more sense)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1236 + } + }, + { + "name": "ImGuiChildFlags_ResizeX", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Allow resize from right border (layout direction). Enable .ini saving (unless ImGuiWindowFlags_NoSavedSettings passed to window flags)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1237 + } + }, + { + "name": "ImGuiChildFlags_ResizeY", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Allow resize from bottom border (layout direction). \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1238 + } + }, + { + "name": "ImGuiChildFlags_AutoResizeX", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Enable auto-resizing width. Read \"IMPORTANT: Size measurement\" details above." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1239 + } + }, + { + "name": "ImGuiChildFlags_AutoResizeY", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Enable auto-resizing height. Read \"IMPORTANT: Size measurement\" details above." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1240 + } + }, + { + "name": "ImGuiChildFlags_AlwaysAutoResize", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Combined with AutoResizeX/AutoResizeY. Always measure size even when child is hidden, always return true, always disable clipping optimization! NOT RECOMMENDED." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1241 + } + }, + { + "name": "ImGuiChildFlags_FrameStyle", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Style the child window like a framed item: use FrameBg, FrameRounding, FrameBorderSize, FramePadding instead of ChildBg, ChildRounding, ChildBorderSize, WindowPadding." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1242 + } + }, + { + "name": "ImGuiChildFlags_NavFlattened", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// [BETA] Share focus scope, allow keyboard/gamepad navigation to cross over parent border to this child or between sibling child windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1243 + } + }, + { + "name": "ImGuiChildFlags_Border", + "value_expression": "ImGuiChildFlags_Borders", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.91.1 (August 2024) for consistency." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1247 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::BeginChild()", + "// (Legacy: bit 0 must always correspond to ImGuiChildFlags_Borders to be backward compatible with old API using 'bool border = false'.", + "// About using AutoResizeX/AutoResizeY flags:", + "// - May be combined with SetNextWindowSizeConstraints() to set a min/max size for each axis (see \"Demo->Child->Auto-resize with Constraints\").", + "// - Size measurement for a given axis is only performed when the child window is within visible boundaries, or is just appearing.", + "// - This allows BeginChild() to return false when not within boundaries (e.g. when scrolling), which is more optimal. BUT it won't update its auto-size while clipped.", + "// While not perfect, it is a better default behavior as the always-on performance gain is more valuable than the occasional \"resizing after becoming visible again\" glitch.", + "// - You may also use ImGuiChildFlags_AlwaysAutoResize to force an update even when child window is not in view.", + "// HOWEVER PLEASE UNDERSTAND THAT DOING SO WILL PREVENT BeginChild() FROM EVER RETURNING FALSE, disabling benefits of coarse clipping." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1232 + } + }, + { + "name": "ImGuiItemFlags_", + "original_fully_qualified_name": "ImGuiItemFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiItemFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "attached": "// (Default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1255 + } + }, + { + "name": "ImGuiItemFlags_NoTabStop", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// false // Disable keyboard tabbing. This is a \"lighter\" version of ImGuiItemFlags_NoNav." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1256 + } + }, + { + "name": "ImGuiItemFlags_NoNav", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// false // Disable any form of focusing (keyboard/gamepad directional navigation and SetKeyboardFocusHere() calls)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1257 + } + }, + { + "name": "ImGuiItemFlags_NoNavDefaultFocus", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// false // Disable item being a candidate for default focus (e.g. used by title bar items)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1258 + } + }, + { + "name": "ImGuiItemFlags_ButtonRepeat", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// false // Any button-like behavior will have repeat mode enabled (based on io.KeyRepeatDelay and io.KeyRepeatRate values). Note that you can also call IsItemActive() after any button to tell if it is being held." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1259 + } + }, + { + "name": "ImGuiItemFlags_AutoClosePopups", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// true // MenuItem()/Selectable() automatically close their parent popup window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1260 + } + }, + { + "name": "ImGuiItemFlags_AllowDuplicateId", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// false // Allow submitting an item with the same identifier as an item already submitted this frame without triggering a warning tooltip if io.ConfigDebugHighlightIdConflicts is set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1261 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::PushItemFlag()", + "// (Those are shared by all items)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1253 + } + }, + { + "name": "ImGuiInputTextFlags_", + "original_fully_qualified_name": "ImGuiInputTextFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiInputTextFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "preceding": [ + "// Basic filters (also see ImGuiInputTextFlags_CallbackCharFilter)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1269 + } + }, + { + "name": "ImGuiInputTextFlags_CharsDecimal", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Allow 0123456789.+-*/" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1270 + } + }, + { + "name": "ImGuiInputTextFlags_CharsHexadecimal", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Allow 0123456789ABCDEFabcdef" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1271 + } + }, + { + "name": "ImGuiInputTextFlags_CharsScientific", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Allow 0123456789.+-*/eE (Scientific notation input)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1272 + } + }, + { + "name": "ImGuiInputTextFlags_CharsUppercase", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Turn a..z into A..Z" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1273 + } + }, + { + "name": "ImGuiInputTextFlags_CharsNoBlank", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Filter out spaces, tabs" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1274 + } + }, + { + "name": "ImGuiInputTextFlags_AllowTabInput", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "preceding": [ + "// Inputs" + ], + "attached": "// Pressing TAB input a '\\t' character into the text field" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1277 + } + }, + { + "name": "ImGuiInputTextFlags_EnterReturnsTrue", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Return 'true' when Enter is pressed (as opposed to every time the value was modified). Consider using IsItemDeactivatedAfterEdit() instead!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1278 + } + }, + { + "name": "ImGuiInputTextFlags_EscapeClearsAll", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Escape key clears content if not empty, and deactivate otherwise (contrast to default behavior of Escape to revert)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1279 + } + }, + { + "name": "ImGuiInputTextFlags_CtrlEnterForNewLine", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// In multi-line mode, validate with Enter, add new line with Ctrl+Enter (default is opposite: validate with Ctrl+Enter, add line with Enter)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1280 + } + }, + { + "name": "ImGuiInputTextFlags_ReadOnly", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "preceding": [ + "// Other options" + ], + "attached": "// Read-only mode" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1283 + } + }, + { + "name": "ImGuiInputTextFlags_Password", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Password mode, display all characters as '*', disable copy" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1284 + } + }, + { + "name": "ImGuiInputTextFlags_AlwaysOverwrite", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Overwrite mode" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1285 + } + }, + { + "name": "ImGuiInputTextFlags_AutoSelectAll", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Select entire text when first taking mouse focus" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1286 + } + }, + { + "name": "ImGuiInputTextFlags_ParseEmptyRefVal", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// InputFloat(), InputInt(), InputScalar() etc. only: parse empty string as zero value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1287 + } + }, + { + "name": "ImGuiInputTextFlags_DisplayEmptyRefVal", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// InputFloat(), InputInt(), InputScalar() etc. only: when value is zero, do not display it. Generally used with ImGuiInputTextFlags_ParseEmptyRefVal." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1288 + } + }, + { + "name": "ImGuiInputTextFlags_NoHorizontalScroll", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Disable following the cursor horizontally" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1289 + } + }, + { + "name": "ImGuiInputTextFlags_NoUndoRedo", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// Disable undo/redo. Note that input text owns the text data while active, if you want to provide your own undo/redo stack you need e.g. to call ClearActiveID()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1290 + } + }, + { + "name": "ImGuiInputTextFlags_ElideLeft", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "preceding": [ + "// Elide display / Alignment" + ], + "attached": "// When text doesn't fit, elide left side to ensure right side stays visible. Useful for path/filenames. Single-line only!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1293 + } + }, + { + "name": "ImGuiInputTextFlags_CallbackCompletion", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "preceding": [ + "// Callback features" + ], + "attached": "// Callback on pressing TAB (for completion handling)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1296 + } + }, + { + "name": "ImGuiInputTextFlags_CallbackHistory", + "value_expression": "1<<19", + "value": 524288, + "is_count": false, + "comments": { + "attached": "// Callback on pressing Up/Down arrows (for history handling)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1297 + } + }, + { + "name": "ImGuiInputTextFlags_CallbackAlways", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// Callback on each iteration. User code may query cursor position, modify text buffer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1298 + } + }, + { + "name": "ImGuiInputTextFlags_CallbackCharFilter", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or discard, or return 1 in callback to discard." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1299 + } + }, + { + "name": "ImGuiInputTextFlags_CallbackResize", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// Callback on buffer capacity changes request (beyond 'buf_size' parameter value), allowing the string to grow. Notify when the string wants to be resized (for string types which hold a cache of their Size). You will be provided a new BufSize in the callback and NEED to honor it. (see misc/cpp/imgui_stdlib.h for an example of using this)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1300 + } + }, + { + "name": "ImGuiInputTextFlags_CallbackEdit", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "attached": "// Callback on any edit. Note that InputText() already returns true on edit + you can always use IsItemEdited(). The callback is useful to manipulate the underlying buffer while focus is active." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1301 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::InputText()", + "// (Those are per-item flags. There are shared flags in ImGuiIO: io.ConfigInputTextCursorBlink and io.ConfigInputTextEnterKeepActive)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1266 + } + }, + { + "name": "ImGuiTreeNodeFlags_", + "original_fully_qualified_name": "ImGuiTreeNodeFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTreeNodeFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1310 + } + }, + { + "name": "ImGuiTreeNodeFlags_Selected", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Draw as selected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1311 + } + }, + { + "name": "ImGuiTreeNodeFlags_Framed", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Draw frame with background (e.g. for CollapsingHeader)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1312 + } + }, + { + "name": "ImGuiTreeNodeFlags_AllowOverlap", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Hit testing to allow subsequent widgets to overlap this one" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1313 + } + }, + { + "name": "ImGuiTreeNodeFlags_NoTreePushOnOpen", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Don't do a TreePush() when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1314 + } + }, + { + "name": "ImGuiTreeNodeFlags_NoAutoOpenOnLog", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1315 + } + }, + { + "name": "ImGuiTreeNodeFlags_DefaultOpen", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Default node to be open" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1316 + } + }, + { + "name": "ImGuiTreeNodeFlags_OpenOnDoubleClick", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Open on double-click instead of simple click (default for multi-select unless any _OpenOnXXX behavior is set explicitly). Both behaviors may be combined." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1317 + } + }, + { + "name": "ImGuiTreeNodeFlags_OpenOnArrow", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Open when clicking on the arrow part (default for multi-select unless any _OpenOnXXX behavior is set explicitly). Both behaviors may be combined." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1318 + } + }, + { + "name": "ImGuiTreeNodeFlags_Leaf", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// No collapsing, no arrow (use as a convenience for leaf nodes)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1319 + } + }, + { + "name": "ImGuiTreeNodeFlags_Bullet", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Display a bullet instead of arrow. IMPORTANT: node can still be marked open/close if you don't set the _Leaf flag!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1320 + } + }, + { + "name": "ImGuiTreeNodeFlags_FramePadding", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Use FramePadding (even for an unframed text node) to vertically align text baseline to regular widget height. Equivalent to calling AlignTextToFramePadding() before the node." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1321 + } + }, + { + "name": "ImGuiTreeNodeFlags_SpanAvailWidth", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Extend hit box to the right-most edge, even if not framed. This is not the default in order to allow adding other items on the same line without using AllowOverlap mode." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1322 + } + }, + { + "name": "ImGuiTreeNodeFlags_SpanFullWidth", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Extend hit box to the left-most and right-most edges (cover the indent area)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1323 + } + }, + { + "name": "ImGuiTreeNodeFlags_SpanLabelWidth", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Narrow hit box + narrow hovering highlight, will only cover the label text." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1324 + } + }, + { + "name": "ImGuiTreeNodeFlags_SpanAllColumns", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Frame will span all columns of its container table (label will still fit in current column)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1325 + } + }, + { + "name": "ImGuiTreeNodeFlags_LabelSpanAllColumns", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Label will span all columns of its container table" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1326 + } + }, + { + "name": "ImGuiTreeNodeFlags_NavLeftJumpsToParent", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "preceding": [ + "//ImGuiTreeNodeFlags_NoScrollOnOpen = 1 << 16, // FIXME: TODO: Disable automatic scroll on TreePop() if node got just open and contents is not visible" + ], + "attached": "// Nav: left arrow moves back to parent. This is processed in TreePop() when there's an unfullfilled Left nav request remaining." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1328 + } + }, + { + "name": "ImGuiTreeNodeFlags_CollapsingHeader", + "value_expression": "ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog", + "value": 26, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1329 + } + }, + { + "name": "ImGuiTreeNodeFlags_DrawLinesNone", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "preceding": [ + "// [EXPERIMENTAL] Draw lines connecting TreeNode hierarchy. Discuss in GitHub issue #2920.", + "// Default value is pulled from style.TreeLinesFlags. May be overridden in TreeNode calls." + ], + "attached": "// No lines drawn" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1333 + } + }, + { + "name": "ImGuiTreeNodeFlags_DrawLinesFull", + "value_expression": "1<<19", + "value": 524288, + "is_count": false, + "comments": { + "attached": "// Horizontal lines to child nodes. Vertical line drawn down to TreePop() position: cover full contents. Faster (for large trees)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1334 + } + }, + { + "name": "ImGuiTreeNodeFlags_DrawLinesToNodes", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// Horizontal lines to child nodes. Vertical line drawn down to bottom-most child node. Slower (for large trees)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1335 + } + }, + { + "name": "ImGuiTreeNodeFlags_NavLeftJumpsBackHere", + "value_expression": "ImGuiTreeNodeFlags_NavLeftJumpsToParent", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.92.0" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1338 + } + }, + { + "name": "ImGuiTreeNodeFlags_SpanTextWidth", + "value_expression": "ImGuiTreeNodeFlags_SpanLabelWidth", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.90.7" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1339 + } + }, + { + "name": "ImGuiTreeNodeFlags_AllowItemOverlap", + "value_expression": "ImGuiTreeNodeFlags_AllowOverlap", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.89.7" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1340 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::TreeNodeEx(), ImGui::CollapsingHeader*()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1308 + } + }, + { + "name": "ImGuiPopupFlags_", + "original_fully_qualified_name": "ImGuiPopupFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiPopupFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1354 + } + }, + { + "name": "ImGuiPopupFlags_MouseButtonLeft", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "attached": "// For BeginPopupContext*(): open on Left Mouse release. Guaranteed to always be == 0 (same as ImGuiMouseButton_Left)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1355 + } + }, + { + "name": "ImGuiPopupFlags_MouseButtonRight", + "value_expression": "1", + "value": 1, + "is_count": false, + "comments": { + "attached": "// For BeginPopupContext*(): open on Right Mouse release. Guaranteed to always be == 1 (same as ImGuiMouseButton_Right)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1356 + } + }, + { + "name": "ImGuiPopupFlags_MouseButtonMiddle", + "value_expression": "2", + "value": 2, + "is_count": false, + "comments": { + "attached": "// For BeginPopupContext*(): open on Middle Mouse release. Guaranteed to always be == 2 (same as ImGuiMouseButton_Middle)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1357 + } + }, + { + "name": "ImGuiPopupFlags_MouseButtonMask_", + "value_expression": "0x1F", + "value": 31, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1358 + } + }, + { + "name": "ImGuiPopupFlags_MouseButtonDefault_", + "value_expression": "1", + "value": 1, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1359 + } + }, + { + "name": "ImGuiPopupFlags_NoReopen", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// For OpenPopup*(), BeginPopupContext*(): don't reopen same popup if already open (won't reposition, won't reinitialize navigation)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1360 + } + }, + { + "name": "ImGuiPopupFlags_NoOpenOverExistingPopup", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "preceding": [ + "//ImGuiPopupFlags_NoReopenAlwaysNavInit = 1 << 6, // For OpenPopup*(), BeginPopupContext*(): focus and initialize navigation even when not reopening." + ], + "attached": "// For OpenPopup*(), BeginPopupContext*(): don't open if there's already a popup at the same level of the popup stack" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1362 + } + }, + { + "name": "ImGuiPopupFlags_NoOpenOverItems", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// For BeginPopupContextWindow(): don't return true when hovering items, only when hovering empty space" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1363 + } + }, + { + "name": "ImGuiPopupFlags_AnyPopupId", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// For IsPopupOpen(): ignore the ImGuiID parameter and test for any popup." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1364 + } + }, + { + "name": "ImGuiPopupFlags_AnyPopupLevel", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// For IsPopupOpen(): search/test at any level of the popup stack (default test in the current level)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1365 + } + }, + { + "name": "ImGuiPopupFlags_AnyPopup", + "value_expression": "ImGuiPopupFlags_AnyPopupId | ImGuiPopupFlags_AnyPopupLevel", + "value": 3072, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1366 + } + } + ], + "comments": { + "preceding": [ + "// Flags for OpenPopup*(), BeginPopupContext*(), IsPopupOpen() functions.", + "// - To be backward compatible with older API which took an 'int mouse_button = 1' argument instead of 'ImGuiPopupFlags flags',", + "// we need to treat small flags values as a mouse button index, so we encode the mouse button in the first few bits of the flags.", + "// It is therefore guaranteed to be legal to pass a mouse button index in ImGuiPopupFlags.", + "// - For the same reason, we exceptionally default the ImGuiPopupFlags argument of BeginPopupContextXXX functions to 1 instead of 0.", + "// IMPORTANT: because the default parameter is 1 (==ImGuiPopupFlags_MouseButtonRight), if you rely on the default parameter", + "// and want to use another flag, you need to pass in the ImGuiPopupFlags_MouseButtonRight flag explicitly.", + "// - Multiple buttons currently cannot be combined/or-ed in those functions (we could allow it later)." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1352 + } + }, + { + "name": "ImGuiSelectableFlags_", + "original_fully_qualified_name": "ImGuiSelectableFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiSelectableFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1372 + } + }, + { + "name": "ImGuiSelectableFlags_NoAutoClosePopups", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Clicking this doesn't close parent popup window (overrides ImGuiItemFlags_AutoClosePopups)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1373 + } + }, + { + "name": "ImGuiSelectableFlags_SpanAllColumns", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Frame will span all columns of its container table (text will still fit in current column)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1374 + } + }, + { + "name": "ImGuiSelectableFlags_AllowDoubleClick", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Generate press events on double clicks too" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1375 + } + }, + { + "name": "ImGuiSelectableFlags_Disabled", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Cannot be selected, display grayed out text" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1376 + } + }, + { + "name": "ImGuiSelectableFlags_AllowOverlap", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// (WIP) Hit testing to allow subsequent widgets to overlap this one" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1377 + } + }, + { + "name": "ImGuiSelectableFlags_Highlight", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Make the item be displayed as if it is hovered" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1378 + } + }, + { + "name": "ImGuiSelectableFlags_DontClosePopups", + "value_expression": "ImGuiSelectableFlags_NoAutoClosePopups", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.91.0" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1381 + } + }, + { + "name": "ImGuiSelectableFlags_AllowItemOverlap", + "value_expression": "ImGuiSelectableFlags_AllowOverlap", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.89.7" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1382 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::Selectable()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1370 + } + }, + { + "name": "ImGuiComboFlags_", + "original_fully_qualified_name": "ImGuiComboFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiComboFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1389 + } + }, + { + "name": "ImGuiComboFlags_PopupAlignLeft", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Align the popup toward the left by default" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1390 + } + }, + { + "name": "ImGuiComboFlags_HeightSmall", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Max ~4 items visible. Tip: If you want your combo popup to be a specific size you can use SetNextWindowSizeConstraints() prior to calling BeginCombo()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1391 + } + }, + { + "name": "ImGuiComboFlags_HeightRegular", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Max ~8 items visible (default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1392 + } + }, + { + "name": "ImGuiComboFlags_HeightLarge", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Max ~20 items visible" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1393 + } + }, + { + "name": "ImGuiComboFlags_HeightLargest", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// As many fitting items as possible" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1394 + } + }, + { + "name": "ImGuiComboFlags_NoArrowButton", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Display on the preview box without the square arrow button" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1395 + } + }, + { + "name": "ImGuiComboFlags_NoPreview", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Display only a square arrow button" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1396 + } + }, + { + "name": "ImGuiComboFlags_WidthFitPreview", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Width dynamically calculated from preview contents" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1397 + } + }, + { + "name": "ImGuiComboFlags_HeightMask_", + "value_expression": "ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest", + "value": 30, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1398 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::BeginCombo()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1387 + } + }, + { + "name": "ImGuiTabBarFlags_", + "original_fully_qualified_name": "ImGuiTabBarFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTabBarFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1404 + } + }, + { + "name": "ImGuiTabBarFlags_Reorderable", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Allow manually dragging tabs to re-order them + New tabs are appended at the end of list" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1405 + } + }, + { + "name": "ImGuiTabBarFlags_AutoSelectNewTabs", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Automatically select new tabs when they appear" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1406 + } + }, + { + "name": "ImGuiTabBarFlags_TabListPopupButton", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Disable buttons to open the tab list popup" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1407 + } + }, + { + "name": "ImGuiTabBarFlags_NoCloseWithMiddleMouseButton", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You may handle this behavior manually on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1408 + } + }, + { + "name": "ImGuiTabBarFlags_NoTabListScrollingButtons", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Disable scrolling buttons (apply when fitting policy is ImGuiTabBarFlags_FittingPolicyScroll)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1409 + } + }, + { + "name": "ImGuiTabBarFlags_NoTooltip", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Disable tooltips when hovering a tab" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1410 + } + }, + { + "name": "ImGuiTabBarFlags_DrawSelectedOverline", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Draw selected overline markers over selected tab" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1411 + } + }, + { + "name": "ImGuiTabBarFlags_FittingPolicyMixed", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "preceding": [ + "// Fitting/Resize policy" + ], + "attached": "// Shrink down tabs when they don't fit, until width is style.TabMinWidthShrink, then enable scrolling buttons." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1414 + } + }, + { + "name": "ImGuiTabBarFlags_FittingPolicyShrink", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Shrink down tabs when they don't fit" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1415 + } + }, + { + "name": "ImGuiTabBarFlags_FittingPolicyScroll", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Enable scrolling buttons when tabs don't fit" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1416 + } + }, + { + "name": "ImGuiTabBarFlags_FittingPolicyMask_", + "value_expression": "ImGuiTabBarFlags_FittingPolicyMixed | ImGuiTabBarFlags_FittingPolicyShrink | ImGuiTabBarFlags_FittingPolicyScroll", + "value": 896, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1417 + } + }, + { + "name": "ImGuiTabBarFlags_FittingPolicyDefault_", + "value_expression": "ImGuiTabBarFlags_FittingPolicyMixed", + "value": 128, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1418 + } + }, + { + "name": "ImGuiTabBarFlags_FittingPolicyResizeDown", + "value_expression": "ImGuiTabBarFlags_FittingPolicyShrink", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.92.2" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1421 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::BeginTabBar()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1402 + } + }, + { + "name": "ImGuiTabItemFlags_", + "original_fully_qualified_name": "ImGuiTabItemFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTabItemFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1428 + } + }, + { + "name": "ImGuiTabItemFlags_UnsavedDocument", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Display a dot next to the title + set ImGuiTabItemFlags_NoAssumedClosure." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1429 + } + }, + { + "name": "ImGuiTabItemFlags_SetSelected", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Trigger flag to programmatically make the tab selected when calling BeginTabItem()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1430 + } + }, + { + "name": "ImGuiTabItemFlags_NoCloseWithMiddleMouseButton", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You may handle this behavior manually on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1431 + } + }, + { + "name": "ImGuiTabItemFlags_NoPushId", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Don't call PushID()/PopID() on BeginTabItem()/EndTabItem()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1432 + } + }, + { + "name": "ImGuiTabItemFlags_NoTooltip", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Disable tooltip for the given tab" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1433 + } + }, + { + "name": "ImGuiTabItemFlags_NoReorder", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Disable reordering this tab or having another tab cross over this tab" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1434 + } + }, + { + "name": "ImGuiTabItemFlags_Leading", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Enforce the tab position to the left of the tab bar (after the tab list popup button)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1435 + } + }, + { + "name": "ImGuiTabItemFlags_Trailing", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Enforce the tab position to the right of the tab bar (before the scrolling buttons)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1436 + } + }, + { + "name": "ImGuiTabItemFlags_NoAssumedClosure", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Tab is selected when trying to close + closure is not immediately assumed (will wait for user to stop submitting the tab). Otherwise closure is assumed when pressing the X, so if you keep submitting the tab may reappear at end of tab bar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1437 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::BeginTabItem()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1426 + } + }, + { + "name": "ImGuiFocusedFlags_", + "original_fully_qualified_name": "ImGuiFocusedFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiFocusedFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1443 + } + }, + { + "name": "ImGuiFocusedFlags_ChildWindows", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Return true if any children of the window is focused" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1444 + } + }, + { + "name": "ImGuiFocusedFlags_RootWindow", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Test from root window (top most parent of the current hierarchy)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1445 + } + }, + { + "name": "ImGuiFocusedFlags_AnyWindow", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Return true if any window is focused. Important: If you are trying to tell how to dispatch your low-level inputs, do NOT use this. Use 'io.WantCaptureMouse' instead! Please read the FAQ!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1446 + } + }, + { + "name": "ImGuiFocusedFlags_NoPopupHierarchy", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1447 + } + }, + { + "name": "ImGuiFocusedFlags_DockHierarchy", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1448 + } + }, + { + "name": "ImGuiFocusedFlags_RootAndChildWindows", + "value_expression": "ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows", + "value": 3, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1449 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::IsWindowFocused()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1441 + } + }, + { + "name": "ImGuiHoveredFlags_", + "original_fully_qualified_name": "ImGuiHoveredFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiHoveredFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "attached": "// Return true if directly over the item/window, not obstructed by another window, not obstructed by an active popup or modal blocking inputs under them." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1457 + } + }, + { + "name": "ImGuiHoveredFlags_ChildWindows", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// IsWindowHovered() only: Return true if any children of the window is hovered" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1458 + } + }, + { + "name": "ImGuiHoveredFlags_RootWindow", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// IsWindowHovered() only: Test from root window (top most parent of the current hierarchy)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1459 + } + }, + { + "name": "ImGuiHoveredFlags_AnyWindow", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// IsWindowHovered() only: Return true if any window is hovered" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1460 + } + }, + { + "name": "ImGuiHoveredFlags_NoPopupHierarchy", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// IsWindowHovered() only: Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1461 + } + }, + { + "name": "ImGuiHoveredFlags_DockHierarchy", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// IsWindowHovered() only: Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1462 + } + }, + { + "name": "ImGuiHoveredFlags_AllowWhenBlockedByPopup", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Return true even if a popup window is normally blocking access to this item/window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1463 + } + }, + { + "name": "ImGuiHoveredFlags_AllowWhenBlockedByActiveItem", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "preceding": [ + "//ImGuiHoveredFlags_AllowWhenBlockedByModal = 1 << 6, // Return true even if a modal popup window is normally blocking access to this item/window. FIXME-TODO: Unavailable yet." + ], + "attached": "// Return true even if an active item is blocking access to this item/window. Useful for Drag and Drop patterns." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1465 + } + }, + { + "name": "ImGuiHoveredFlags_AllowWhenOverlappedByItem", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Return true even if the item uses AllowOverlap mode and is overlapped by another hoverable item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1466 + } + }, + { + "name": "ImGuiHoveredFlags_AllowWhenOverlappedByWindow", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Return true even if the position is obstructed or overlapped by another window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1467 + } + }, + { + "name": "ImGuiHoveredFlags_AllowWhenDisabled", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Return true even if the item is disabled" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1468 + } + }, + { + "name": "ImGuiHoveredFlags_NoNavOverride", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Disable using keyboard/gamepad navigation state when active, always query mouse" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1469 + } + }, + { + "name": "ImGuiHoveredFlags_AllowWhenOverlapped", + "value_expression": "ImGuiHoveredFlags_AllowWhenOverlappedByItem | ImGuiHoveredFlags_AllowWhenOverlappedByWindow", + "value": 768, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1470 + } + }, + { + "name": "ImGuiHoveredFlags_RectOnly", + "value_expression": "ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped", + "value": 928, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1471 + } + }, + { + "name": "ImGuiHoveredFlags_RootAndChildWindows", + "value_expression": "ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows", + "value": 3, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1472 + } + }, + { + "name": "ImGuiHoveredFlags_ForTooltip", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "preceding": [ + "// Tooltips mode", + "// - typically used in IsItemHovered() + SetTooltip() sequence.", + "// - this is a shortcut to pull flags from 'style.HoverFlagsForTooltipMouse' or 'style.HoverFlagsForTooltipNav' where you can reconfigure desired behavior.", + "// e.g. 'TooltipHoveredFlagsForMouse' defaults to 'ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayShort'.", + "// - for frequently actioned or hovered items providing a tooltip, you want may to use ImGuiHoveredFlags_ForTooltip (stationary + delay) so the tooltip doesn't show too often.", + "// - for items which main purpose is to be hovered, or items with low affordance, or in less consistent apps, prefer no delay or shorter delay." + ], + "attached": "// Shortcut for standard flags when using IsItemHovered() + SetTooltip() sequence." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1480 + } + }, + { + "name": "ImGuiHoveredFlags_Stationary", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "preceding": [ + "// (Advanced) Mouse Hovering delays.", + "// - generally you can use ImGuiHoveredFlags_ForTooltip to use application-standardized flags.", + "// - use those if you need specific overrides." + ], + "attached": "// Require mouse to be stationary for style.HoverStationaryDelay (~0.15 sec) _at least one time_. After this, can move on same item/window. Using the stationary test tends to reduces the need for a long delay." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1485 + } + }, + { + "name": "ImGuiHoveredFlags_DelayNone", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Return true immediately (default). As this is the default you generally ignore this." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1486 + } + }, + { + "name": "ImGuiHoveredFlags_DelayShort", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Return true after style.HoverDelayShort elapsed (~0.15 sec) (shared between items) + requires mouse to be stationary for style.HoverStationaryDelay (once per item)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1487 + } + }, + { + "name": "ImGuiHoveredFlags_DelayNormal", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Return true after style.HoverDelayNormal elapsed (~0.40 sec) (shared between items) + requires mouse to be stationary for style.HoverStationaryDelay (once per item)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1488 + } + }, + { + "name": "ImGuiHoveredFlags_NoSharedDelay", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// IsItemHovered() only: Disable shared delay system where moving from one item to the next keeps the previous timer for a short time (standard for tooltips with long delays)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1489 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::IsItemHovered(), ImGui::IsWindowHovered()", + "// Note: if you are trying to check whether your mouse should be dispatched to Dear ImGui or to your app, you should use 'io.WantCaptureMouse' instead! Please read the FAQ!", + "// Note: windows with the ImGuiWindowFlags_NoInputs flag are ignored by IsWindowHovered() calls." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1455 + } + }, + { + "name": "ImGuiDockNodeFlags_", + "original_fully_qualified_name": "ImGuiDockNodeFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiDockNodeFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1497 + } + }, + { + "name": "ImGuiDockNodeFlags_KeepAliveOnly", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// // Don't display the dockspace node but keep it alive. Windows docked into this dockspace node won't be undocked." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1498 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDockingOverCentralNode", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "preceding": [ + "//ImGuiDockNodeFlags_NoCentralNode = 1 << 1, // // Disable Central Node (the node which can stay empty)" + ], + "attached": "// // Disable docking over the Central Node, which will be always kept empty." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1500 + } + }, + { + "name": "ImGuiDockNodeFlags_PassthruCentralNode", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// // Enable passthru dockspace: 1) DockSpace() will render a ImGuiCol_WindowBg background covering everything excepted the Central Node when empty. Meaning the host window should probably use SetNextWindowBgAlpha(0.0f) prior to Begin() when using this. 2) When Central Node is empty: let inputs pass-through + won't display a DockingEmptyBg background. See demo for details." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1501 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDockingSplit", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// // Disable other windows/nodes from splitting this node." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1502 + } + }, + { + "name": "ImGuiDockNodeFlags_NoResize", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Saved // Disable resizing node using the splitter/separators. Useful with programmatically setup dockspaces." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1503 + } + }, + { + "name": "ImGuiDockNodeFlags_AutoHideTabBar", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// // Tab bar will automatically hide when there is a single window in the dock node." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1504 + } + }, + { + "name": "ImGuiDockNodeFlags_NoUndocking", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// // Disable undocking this node." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1505 + } + }, + { + "name": "ImGuiDockNodeFlags_NoSplit", + "value_expression": "ImGuiDockNodeFlags_NoDockingSplit", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.90" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1508 + } + }, + { + "name": "ImGuiDockNodeFlags_NoDockingInCentralNode", + "value_expression": "ImGuiDockNodeFlags_NoDockingOverCentralNode", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.90" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1509 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::DockSpace(), shared/inherited by child nodes.", + "// (Some flags can be applied to individual nodes directly)", + "// FIXME-DOCK: Also see ImGuiDockNodeFlagsPrivate_ which may involve using the WIP and internal DockBuilder api." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1495 + } + }, + { + "name": "ImGuiDragDropFlags_", + "original_fully_qualified_name": "ImGuiDragDropFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiDragDropFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1516 + } + }, + { + "name": "ImGuiDragDropFlags_SourceNoPreviewTooltip", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "preceding": [ + "// BeginDragDropSource() flags" + ], + "attached": "// Disable preview tooltip. By default, a successful call to BeginDragDropSource opens a tooltip so you can display a preview or description of the source contents. This flag disables this behavior." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1518 + } + }, + { + "name": "ImGuiDragDropFlags_SourceNoDisableHover", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// By default, when dragging we clear data so that IsItemHovered() will return false, to avoid subsequent user code submitting tooltips. This flag disables this behavior so you can still call IsItemHovered() on the source item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1519 + } + }, + { + "name": "ImGuiDragDropFlags_SourceNoHoldToOpenOthers", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Disable the behavior that allows to open tree nodes and collapsing header by holding over them while dragging a source item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1520 + } + }, + { + "name": "ImGuiDragDropFlags_SourceAllowNullID", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Allow items such as Text(), Image() that have no unique identifier to be used as drag source, by manufacturing a temporary identifier based on their window-relative position. This is extremely unusual within the dear imgui ecosystem and so we made it explicit." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1521 + } + }, + { + "name": "ImGuiDragDropFlags_SourceExtern", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// External source (from outside of dear imgui), won't attempt to read current item/window info. Will always return true. Only one Extern source can be active simultaneously." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1522 + } + }, + { + "name": "ImGuiDragDropFlags_PayloadAutoExpire", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Automatically expire the payload if the source cease to be submitted (otherwise payloads are persisting while being dragged)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1523 + } + }, + { + "name": "ImGuiDragDropFlags_PayloadNoCrossContext", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Hint to specify that the payload may not be copied outside current dear imgui context." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1524 + } + }, + { + "name": "ImGuiDragDropFlags_PayloadNoCrossProcess", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Hint to specify that the payload may not be copied outside current process." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1525 + } + }, + { + "name": "ImGuiDragDropFlags_AcceptBeforeDelivery", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "preceding": [ + "// AcceptDragDropPayload() flags" + ], + "attached": "// AcceptDragDropPayload() will returns true even before the mouse button is released. You can then call IsDelivery() to test if the payload needs to be delivered." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1527 + } + }, + { + "name": "ImGuiDragDropFlags_AcceptNoDrawDefaultRect", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Do not draw the default highlight rectangle when hovering over target." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1528 + } + }, + { + "name": "ImGuiDragDropFlags_AcceptNoPreviewTooltip", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Request hiding the BeginDragDropSource tooltip from the BeginDragDropTarget site." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1529 + } + }, + { + "name": "ImGuiDragDropFlags_AcceptPeekOnly", + "value_expression": "ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect", + "value": 3072, + "is_count": false, + "comments": { + "attached": "// For peeking ahead and inspecting the payload before delivery." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1530 + } + }, + { + "name": "ImGuiDragDropFlags_SourceAutoExpirePayload", + "value_expression": "ImGuiDragDropFlags_PayloadAutoExpire", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.90.9" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1533 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::BeginDragDropSource(), ImGui::AcceptDragDropPayload()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1514 + } + }, + { + "name": "ImGuiDataType_", + "original_fully_qualified_name": "ImGuiDataType_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiDataType_S8", + "value": 0, + "is_count": false, + "comments": { + "attached": "// signed char / char (with sensible compilers)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1544 + } + }, + { + "name": "ImGuiDataType_U8", + "value": 1, + "is_count": false, + "comments": { + "attached": "// unsigned char" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1545 + } + }, + { + "name": "ImGuiDataType_S16", + "value": 2, + "is_count": false, + "comments": { + "attached": "// short" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1546 + } + }, + { + "name": "ImGuiDataType_U16", + "value": 3, + "is_count": false, + "comments": { + "attached": "// unsigned short" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1547 + } + }, + { + "name": "ImGuiDataType_S32", + "value": 4, + "is_count": false, + "comments": { + "attached": "// int" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1548 + } + }, + { + "name": "ImGuiDataType_U32", + "value": 5, + "is_count": false, + "comments": { + "attached": "// unsigned int" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1549 + } + }, + { + "name": "ImGuiDataType_S64", + "value": 6, + "is_count": false, + "comments": { + "attached": "// long long / __int64" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1550 + } + }, + { + "name": "ImGuiDataType_U64", + "value": 7, + "is_count": false, + "comments": { + "attached": "// unsigned long long / unsigned __int64" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1551 + } + }, + { + "name": "ImGuiDataType_Float", + "value": 8, + "is_count": false, + "comments": { + "attached": "// float" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1552 + } + }, + { + "name": "ImGuiDataType_Double", + "value": 9, + "is_count": false, + "comments": { + "attached": "// double" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1553 + } + }, + { + "name": "ImGuiDataType_Bool", + "value": 10, + "is_count": false, + "comments": { + "attached": "// bool (provided for user convenience, not supported by scalar widgets)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1554 + } + }, + { + "name": "ImGuiDataType_String", + "value": 11, + "is_count": false, + "comments": { + "attached": "// char* (provided for user convenience, not supported by scalar widgets)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1555 + } + }, + { + "name": "ImGuiDataType_COUNT", + "value": 12, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1556 + } + } + ], + "comments": { + "preceding": [ + "// A primary data type" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1542 + } + }, + { + "name": "ImGuiDir", + "original_fully_qualified_name": "ImGuiDir", + "storage_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiDir_None", + "value_expression": "-1", + "value": -1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1562 + } + }, + { + "name": "ImGuiDir_Left", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1563 + } + }, + { + "name": "ImGuiDir_Right", + "value_expression": "1", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1564 + } + }, + { + "name": "ImGuiDir_Up", + "value_expression": "2", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1565 + } + }, + { + "name": "ImGuiDir_Down", + "value_expression": "3", + "value": 3, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1566 + } + }, + { + "name": "ImGuiDir_COUNT", + "value": 4, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1567 + } + } + ], + "comments": { + "preceding": [ + "// A cardinal direction" + ], + "attached": "// Forward declared enum type ImGuiDir" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1560 + } + }, + { + "name": "ImGuiSortDirection", + "original_fully_qualified_name": "ImGuiSortDirection", + "storage_type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiSortDirection_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1573 + } + }, + { + "name": "ImGuiSortDirection_Ascending", + "value_expression": "1", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Ascending = 0->9, A->Z etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1574 + } + }, + { + "name": "ImGuiSortDirection_Descending", + "value_expression": "2", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Descending = 9->0, Z->A etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1575 + } + } + ], + "comments": { + "preceding": [ + "// A sorting direction" + ], + "attached": "// Forward declared enum type ImGuiSortDirection" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1571 + } + }, + { + "name": "ImGuiKey", + "original_fully_qualified_name": "ImGuiKey", + "storage_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiKey_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "preceding": [ + "// Keyboard" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1587 + } + }, + { + "name": "ImGuiKey_NamedKey_BEGIN", + "value_expression": "512", + "value": 512, + "is_count": false, + "comments": { + "attached": "// First valid key value (other than 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1588 + } + }, + { + "name": "ImGuiKey_Tab", + "value_expression": "512", + "value": 512, + "is_count": false, + "comments": { + "attached": "// == ImGuiKey_NamedKey_BEGIN" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1590 + } + }, + { + "name": "ImGuiKey_LeftArrow", + "value": 513, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1591 + } + }, + { + "name": "ImGuiKey_RightArrow", + "value": 514, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1592 + } + }, + { + "name": "ImGuiKey_UpArrow", + "value": 515, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1593 + } + }, + { + "name": "ImGuiKey_DownArrow", + "value": 516, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1594 + } + }, + { + "name": "ImGuiKey_PageUp", + "value": 517, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1595 + } + }, + { + "name": "ImGuiKey_PageDown", + "value": 518, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1596 + } + }, + { + "name": "ImGuiKey_Home", + "value": 519, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1597 + } + }, + { + "name": "ImGuiKey_End", + "value": 520, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1598 + } + }, + { + "name": "ImGuiKey_Insert", + "value": 521, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1599 + } + }, + { + "name": "ImGuiKey_Delete", + "value": 522, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1600 + } + }, + { + "name": "ImGuiKey_Backspace", + "value": 523, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1601 + } + }, + { + "name": "ImGuiKey_Space", + "value": 524, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1602 + } + }, + { + "name": "ImGuiKey_Enter", + "value": 525, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1603 + } + }, + { + "name": "ImGuiKey_Escape", + "value": 526, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1604 + } + }, + { + "name": "ImGuiKey_LeftCtrl", + "value": 527, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1605 + } + }, + { + "name": "ImGuiKey_LeftShift", + "value": 528, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1605 + } + }, + { + "name": "ImGuiKey_LeftAlt", + "value": 529, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1605 + } + }, + { + "name": "ImGuiKey_LeftSuper", + "value": 530, + "is_count": false, + "comments": { + "attached": "// Also see ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiMod_Alt, ImGuiMod_Super below!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1605 + } + }, + { + "name": "ImGuiKey_RightCtrl", + "value": 531, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1606 + } + }, + { + "name": "ImGuiKey_RightShift", + "value": 532, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1606 + } + }, + { + "name": "ImGuiKey_RightAlt", + "value": 533, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1606 + } + }, + { + "name": "ImGuiKey_RightSuper", + "value": 534, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1606 + } + }, + { + "name": "ImGuiKey_Menu", + "value": 535, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1607 + } + }, + { + "name": "ImGuiKey_0", + "value": 536, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_1", + "value": 537, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_2", + "value": 538, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_3", + "value": 539, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_4", + "value": 540, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_5", + "value": 541, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_6", + "value": 542, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_7", + "value": 543, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_8", + "value": 544, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_9", + "value": 545, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1608 + } + }, + { + "name": "ImGuiKey_A", + "value": 546, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_B", + "value": 547, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_C", + "value": 548, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_D", + "value": 549, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_E", + "value": 550, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_F", + "value": 551, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_G", + "value": 552, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_H", + "value": 553, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_I", + "value": 554, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_J", + "value": 555, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1609 + } + }, + { + "name": "ImGuiKey_K", + "value": 556, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_L", + "value": 557, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_M", + "value": 558, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_N", + "value": 559, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_O", + "value": 560, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_P", + "value": 561, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_Q", + "value": 562, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_R", + "value": 563, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_S", + "value": 564, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_T", + "value": 565, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1610 + } + }, + { + "name": "ImGuiKey_U", + "value": 566, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1611 + } + }, + { + "name": "ImGuiKey_V", + "value": 567, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1611 + } + }, + { + "name": "ImGuiKey_W", + "value": 568, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1611 + } + }, + { + "name": "ImGuiKey_X", + "value": 569, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1611 + } + }, + { + "name": "ImGuiKey_Y", + "value": 570, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1611 + } + }, + { + "name": "ImGuiKey_Z", + "value": 571, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1611 + } + }, + { + "name": "ImGuiKey_F1", + "value": 572, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1612 + } + }, + { + "name": "ImGuiKey_F2", + "value": 573, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1612 + } + }, + { + "name": "ImGuiKey_F3", + "value": 574, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1612 + } + }, + { + "name": "ImGuiKey_F4", + "value": 575, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1612 + } + }, + { + "name": "ImGuiKey_F5", + "value": 576, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1612 + } + }, + { + "name": "ImGuiKey_F6", + "value": 577, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1612 + } + }, + { + "name": "ImGuiKey_F7", + "value": 578, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1613 + } + }, + { + "name": "ImGuiKey_F8", + "value": 579, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1613 + } + }, + { + "name": "ImGuiKey_F9", + "value": 580, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1613 + } + }, + { + "name": "ImGuiKey_F10", + "value": 581, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1613 + } + }, + { + "name": "ImGuiKey_F11", + "value": 582, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1613 + } + }, + { + "name": "ImGuiKey_F12", + "value": 583, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1613 + } + }, + { + "name": "ImGuiKey_F13", + "value": 584, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1614 + } + }, + { + "name": "ImGuiKey_F14", + "value": 585, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1614 + } + }, + { + "name": "ImGuiKey_F15", + "value": 586, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1614 + } + }, + { + "name": "ImGuiKey_F16", + "value": 587, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1614 + } + }, + { + "name": "ImGuiKey_F17", + "value": 588, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1614 + } + }, + { + "name": "ImGuiKey_F18", + "value": 589, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1614 + } + }, + { + "name": "ImGuiKey_F19", + "value": 590, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1615 + } + }, + { + "name": "ImGuiKey_F20", + "value": 591, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1615 + } + }, + { + "name": "ImGuiKey_F21", + "value": 592, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1615 + } + }, + { + "name": "ImGuiKey_F22", + "value": 593, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1615 + } + }, + { + "name": "ImGuiKey_F23", + "value": 594, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1615 + } + }, + { + "name": "ImGuiKey_F24", + "value": 595, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1615 + } + }, + { + "name": "ImGuiKey_Apostrophe", + "value": 596, + "is_count": false, + "comments": { + "attached": "// '" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1616 + } + }, + { + "name": "ImGuiKey_Comma", + "value": 597, + "is_count": false, + "comments": { + "attached": "// ," + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1617 + } + }, + { + "name": "ImGuiKey_Minus", + "value": 598, + "is_count": false, + "comments": { + "attached": "// -" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1618 + } + }, + { + "name": "ImGuiKey_Period", + "value": 599, + "is_count": false, + "comments": { + "attached": "// ." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1619 + } + }, + { + "name": "ImGuiKey_Slash", + "value": 600, + "is_count": false, + "comments": { + "attached": "// /" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1620 + } + }, + { + "name": "ImGuiKey_Semicolon", + "value": 601, + "is_count": false, + "comments": { + "attached": "// ;" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1621 + } + }, + { + "name": "ImGuiKey_Equal", + "value": 602, + "is_count": false, + "comments": { + "attached": "// =" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1622 + } + }, + { + "name": "ImGuiKey_LeftBracket", + "value": 603, + "is_count": false, + "comments": { + "attached": "// [" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1623 + } + }, + { + "name": "ImGuiKey_Backslash", + "value": 604, + "is_count": false, + "comments": { + "attached": "// \\ (this text inhibit multiline comment caused by backslash)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1624 + } + }, + { + "name": "ImGuiKey_RightBracket", + "value": 605, + "is_count": false, + "comments": { + "attached": "// ]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1625 + } + }, + { + "name": "ImGuiKey_GraveAccent", + "value": 606, + "is_count": false, + "comments": { + "attached": "// `" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1626 + } + }, + { + "name": "ImGuiKey_CapsLock", + "value": 607, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1627 + } + }, + { + "name": "ImGuiKey_ScrollLock", + "value": 608, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1628 + } + }, + { + "name": "ImGuiKey_NumLock", + "value": 609, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1629 + } + }, + { + "name": "ImGuiKey_PrintScreen", + "value": 610, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1630 + } + }, + { + "name": "ImGuiKey_Pause", + "value": 611, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1631 + } + }, + { + "name": "ImGuiKey_Keypad0", + "value": 612, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1632 + } + }, + { + "name": "ImGuiKey_Keypad1", + "value": 613, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1632 + } + }, + { + "name": "ImGuiKey_Keypad2", + "value": 614, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1632 + } + }, + { + "name": "ImGuiKey_Keypad3", + "value": 615, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1632 + } + }, + { + "name": "ImGuiKey_Keypad4", + "value": 616, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1632 + } + }, + { + "name": "ImGuiKey_Keypad5", + "value": 617, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1633 + } + }, + { + "name": "ImGuiKey_Keypad6", + "value": 618, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1633 + } + }, + { + "name": "ImGuiKey_Keypad7", + "value": 619, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1633 + } + }, + { + "name": "ImGuiKey_Keypad8", + "value": 620, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1633 + } + }, + { + "name": "ImGuiKey_Keypad9", + "value": 621, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1633 + } + }, + { + "name": "ImGuiKey_KeypadDecimal", + "value": 622, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1634 + } + }, + { + "name": "ImGuiKey_KeypadDivide", + "value": 623, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1635 + } + }, + { + "name": "ImGuiKey_KeypadMultiply", + "value": 624, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1636 + } + }, + { + "name": "ImGuiKey_KeypadSubtract", + "value": 625, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1637 + } + }, + { + "name": "ImGuiKey_KeypadAdd", + "value": 626, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1638 + } + }, + { + "name": "ImGuiKey_KeypadEnter", + "value": 627, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1639 + } + }, + { + "name": "ImGuiKey_KeypadEqual", + "value": 628, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1640 + } + }, + { + "name": "ImGuiKey_AppBack", + "value": 629, + "is_count": false, + "comments": { + "attached": "// Available on some keyboard/mouses. Often referred as \"Browser Back\"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1641 + } + }, + { + "name": "ImGuiKey_AppForward", + "value": 630, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1642 + } + }, + { + "name": "ImGuiKey_Oem102", + "value": 631, + "is_count": false, + "comments": { + "attached": "// Non-US backslash." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1643 + } + }, + { + "name": "ImGuiKey_GamepadStart", + "value": 632, + "is_count": false, + "comments": { + "preceding": [ + "// Gamepad", + "// (analog values are 0.0f to 1.0f)", + "// (download controller mapping PNG/PSD at http://dearimgui.com/controls_sheets)", + "// // XBOX | SWITCH | PLAYSTA. | -> ACTION" + ], + "attached": "// Menu | + | Options |" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1649 + } + }, + { + "name": "ImGuiKey_GamepadBack", + "value": 633, + "is_count": false, + "comments": { + "attached": "// View | - | Share |" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1650 + } + }, + { + "name": "ImGuiKey_GamepadFaceLeft", + "value": 634, + "is_count": false, + "comments": { + "attached": "// X | Y | Square | Tap: Toggle Menu. Hold: Windowing mode (Focus/Move/Resize windows)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1651 + } + }, + { + "name": "ImGuiKey_GamepadFaceRight", + "value": 635, + "is_count": false, + "comments": { + "attached": "// B | A | Circle | Cancel / Close / Exit" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1652 + } + }, + { + "name": "ImGuiKey_GamepadFaceUp", + "value": 636, + "is_count": false, + "comments": { + "attached": "// Y | X | Triangle | Text Input / On-screen Keyboard" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1653 + } + }, + { + "name": "ImGuiKey_GamepadFaceDown", + "value": 637, + "is_count": false, + "comments": { + "attached": "// A | B | Cross | Activate / Open / Toggle / Tweak" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1654 + } + }, + { + "name": "ImGuiKey_GamepadDpadLeft", + "value": 638, + "is_count": false, + "comments": { + "attached": "// D-pad Left | \" | \" | Move / Tweak / Resize Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1655 + } + }, + { + "name": "ImGuiKey_GamepadDpadRight", + "value": 639, + "is_count": false, + "comments": { + "attached": "// D-pad Right | \" | \" | Move / Tweak / Resize Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1656 + } + }, + { + "name": "ImGuiKey_GamepadDpadUp", + "value": 640, + "is_count": false, + "comments": { + "attached": "// D-pad Up | \" | \" | Move / Tweak / Resize Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1657 + } + }, + { + "name": "ImGuiKey_GamepadDpadDown", + "value": 641, + "is_count": false, + "comments": { + "attached": "// D-pad Down | \" | \" | Move / Tweak / Resize Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1658 + } + }, + { + "name": "ImGuiKey_GamepadL1", + "value": 642, + "is_count": false, + "comments": { + "attached": "// L Bumper | L | L1 | Tweak Slower / Focus Previous (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1659 + } + }, + { + "name": "ImGuiKey_GamepadR1", + "value": 643, + "is_count": false, + "comments": { + "attached": "// R Bumper | R | R1 | Tweak Faster / Focus Next (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1660 + } + }, + { + "name": "ImGuiKey_GamepadL2", + "value": 644, + "is_count": false, + "comments": { + "attached": "// L Trigger | ZL | L2 | [Analog]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1661 + } + }, + { + "name": "ImGuiKey_GamepadR2", + "value": 645, + "is_count": false, + "comments": { + "attached": "// R Trigger | ZR | R2 | [Analog]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1662 + } + }, + { + "name": "ImGuiKey_GamepadL3", + "value": 646, + "is_count": false, + "comments": { + "attached": "// L Stick | L3 | L3 |" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1663 + } + }, + { + "name": "ImGuiKey_GamepadR3", + "value": 647, + "is_count": false, + "comments": { + "attached": "// R Stick | R3 | R3 |" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1664 + } + }, + { + "name": "ImGuiKey_GamepadLStickLeft", + "value": 648, + "is_count": false, + "comments": { + "attached": "// | | | [Analog] Move Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1665 + } + }, + { + "name": "ImGuiKey_GamepadLStickRight", + "value": 649, + "is_count": false, + "comments": { + "attached": "// | | | [Analog] Move Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1666 + } + }, + { + "name": "ImGuiKey_GamepadLStickUp", + "value": 650, + "is_count": false, + "comments": { + "attached": "// | | | [Analog] Move Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1667 + } + }, + { + "name": "ImGuiKey_GamepadLStickDown", + "value": 651, + "is_count": false, + "comments": { + "attached": "// | | | [Analog] Move Window (in Windowing mode)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1668 + } + }, + { + "name": "ImGuiKey_GamepadRStickLeft", + "value": 652, + "is_count": false, + "comments": { + "attached": "// | | | [Analog]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1669 + } + }, + { + "name": "ImGuiKey_GamepadRStickRight", + "value": 653, + "is_count": false, + "comments": { + "attached": "// | | | [Analog]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1670 + } + }, + { + "name": "ImGuiKey_GamepadRStickUp", + "value": 654, + "is_count": false, + "comments": { + "attached": "// | | | [Analog]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1671 + } + }, + { + "name": "ImGuiKey_GamepadRStickDown", + "value": 655, + "is_count": false, + "comments": { + "attached": "// | | | [Analog]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1672 + } + }, + { + "name": "ImGuiKey_MouseLeft", + "value": 656, + "is_count": false, + "comments": { + "preceding": [ + "// Aliases: Mouse Buttons (auto-submitted from AddMouseButtonEvent() calls)", + "// - This is mirroring the data also written to io.MouseDown[], io.MouseWheel, in a format allowing them to be accessed via standard key API." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1676 + } + }, + { + "name": "ImGuiKey_MouseRight", + "value": 657, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1676 + } + }, + { + "name": "ImGuiKey_MouseMiddle", + "value": 658, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1676 + } + }, + { + "name": "ImGuiKey_MouseX1", + "value": 659, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1676 + } + }, + { + "name": "ImGuiKey_MouseX2", + "value": 660, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1676 + } + }, + { + "name": "ImGuiKey_MouseWheelX", + "value": 661, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1676 + } + }, + { + "name": "ImGuiKey_MouseWheelY", + "value": 662, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1676 + } + }, + { + "name": "ImGuiKey_ReservedForModCtrl", + "value": 663, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal] Reserved for mod storage" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1679 + } + }, + { + "name": "ImGuiKey_ReservedForModShift", + "value": 664, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1679 + } + }, + { + "name": "ImGuiKey_ReservedForModAlt", + "value": 665, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1679 + } + }, + { + "name": "ImGuiKey_ReservedForModSuper", + "value": 666, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1679 + } + }, + { + "name": "ImGuiKey_NamedKey_END", + "value": 667, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal] If you need to iterate all keys (for e.g. an input mapper) you may use ImGuiKey_NamedKey_BEGIN..ImGuiKey_NamedKey_END." + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1682 + } + }, + { + "name": "ImGuiKey_NamedKey_COUNT", + "value_expression": "ImGuiKey_NamedKey_END-ImGuiKey_NamedKey_BEGIN", + "value": 155, + "is_count": true, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1683 + } + }, + { + "name": "ImGuiMod_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "preceding": [ + "// Keyboard Modifiers (explicitly submitted by backend via AddKeyEvent() calls)", + "// - Any functions taking a ImGuiKeyChord parameter can binary-or those with regular keys, e.g. Shortcut(ImGuiMod_Ctrl | ImGuiKey_S).", + "// - Those are written back into io.KeyCtrl, io.KeyShift, io.KeyAlt, io.KeySuper for convenience,", + "// but may be accessed via standard key API such as IsKeyPressed(), IsKeyReleased(), querying duration etc.", + "// - Code polling every key (e.g. an interface to detect a key press for input mapping) might want to ignore those", + "// and prefer using the real keys (e.g. ImGuiKey_LeftCtrl, ImGuiKey_RightCtrl instead of ImGuiMod_Ctrl).", + "// - In theory the value of keyboard modifiers should be roughly equivalent to a logical or of the equivalent left/right keys.", + "// In practice: it's complicated; mods are often provided from different sources. Keyboard layout, IME, sticky keys and", + "// backends tend to interfere and break that equivalence. The safer decision is to relay that ambiguity down to the end-user...", + "// - On macOS, we swap Cmd(Super) and Ctrl keys at the time of the io.AddKeyEvent() call." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1695 + } + }, + { + "name": "ImGuiMod_Ctrl", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Ctrl (non-macOS), Cmd (macOS)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1696 + } + }, + { + "name": "ImGuiMod_Shift", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Shift" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1697 + } + }, + { + "name": "ImGuiMod_Alt", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Option/Menu" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1698 + } + }, + { + "name": "ImGuiMod_Super", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Windows/Super (non-macOS), Ctrl (macOS)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1699 + } + }, + { + "name": "ImGuiMod_Mask_", + "value_expression": "0xF000", + "value": 61440, + "is_count": false, + "comments": { + "attached": "// 4-bits" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1700 + } + }, + { + "name": "ImGuiKey_COUNT", + "value_expression": "ImGuiKey_NamedKey_END", + "value": 667, + "is_count": true, + "comments": { + "attached": "// Obsoleted in 1.91.5 because it was extremely misleading (since named keys don't start at 0 anymore)" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1703 + } + }, + { + "name": "ImGuiMod_Shortcut", + "value_expression": "ImGuiMod_Ctrl", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Removed in 1.90.7, you can now simply use ImGuiMod_Ctrl" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1704 + } + }, + { + "name": "ImGuiKey_ModCtrl", + "value_expression": "ImGuiMod_Ctrl", + "value": 4096, + "is_count": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1705 + } + }, + { + "name": "ImGuiKey_ModShift", + "value_expression": "ImGuiMod_Shift", + "value": 8192, + "is_count": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1705 + } + }, + { + "name": "ImGuiKey_ModAlt", + "value_expression": "ImGuiMod_Alt", + "value": 16384, + "is_count": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1705 + } + }, + { + "name": "ImGuiKey_ModSuper", + "value_expression": "ImGuiMod_Super", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Renamed in 1.89" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1705 + } + } + ], + "comments": { + "preceding": [ + "// A key identifier (ImGuiKey_XXX or ImGuiMod_XXX value): can represent Keyboard, Mouse and Gamepad values.", + "// All our named keys are >= 512. Keys value 0 to 511 are left unused and were legacy native/opaque key values (< 1.87).", + "// Support for legacy keys was completely removed in 1.91.5.", + "// Read details about the 1.87+ transition : https://github.com/ocornut/imgui/issues/4921", + "// Note that \"Keys\" related to physical keys and are not the same concept as input \"Characters\", the later are submitted via io.AddInputCharacter().", + "// The keyboard key enum values are named after the keys on a standard US keyboard, and on other keyboard types the keys reported may not match the keycaps." + ], + "attached": "// Forward declared enum type ImGuiKey" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1584 + } + }, + { + "name": "ImGuiInputFlags_", + "original_fully_qualified_name": "ImGuiInputFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiInputFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1715 + } + }, + { + "name": "ImGuiInputFlags_Repeat", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Enable repeat. Return true on successive repeats. Default for legacy IsKeyPressed(). NOT Default for legacy IsMouseClicked(). MUST BE == 1." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1716 + } + }, + { + "name": "ImGuiInputFlags_RouteActive", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "preceding": [ + "// Flags for Shortcut(), SetNextItemShortcut()", + "// - Routing policies: RouteGlobal+OverActive >> RouteActive or RouteFocused (if owner is active item) >> RouteGlobal+OverFocused >> RouteFocused (if in focused window stack) >> RouteGlobal.", + "// - Default policy is RouteFocused. Can select only 1 policy among all available." + ], + "attached": "// Route to active item only." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1721 + } + }, + { + "name": "ImGuiInputFlags_RouteFocused", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Route to windows in the focus stack (DEFAULT). Deep-most focused window takes inputs. Active item takes inputs over deep-most focused window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1722 + } + }, + { + "name": "ImGuiInputFlags_RouteGlobal", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Global route (unless a focused window or active item registered the route)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1723 + } + }, + { + "name": "ImGuiInputFlags_RouteAlways", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Do not register route, poll keys directly." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1724 + } + }, + { + "name": "ImGuiInputFlags_RouteOverFocused", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "preceding": [ + "// - Routing options" + ], + "attached": "// Option: global route: higher priority than focused route (unless active item in focused route)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1726 + } + }, + { + "name": "ImGuiInputFlags_RouteOverActive", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Option: global route: higher priority than active item. Unlikely you need to use that: will interfere with every active items, e.g. CTRL+A registered by InputText will be overridden by this. May not be fully honored as user/internal code is likely to always assume they can access keys when active." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1727 + } + }, + { + "name": "ImGuiInputFlags_RouteUnlessBgFocused", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// Option: global route: will not be applied if underlying background/void is focused (== no Dear ImGui windows are focused). Useful for overlay applications." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1728 + } + }, + { + "name": "ImGuiInputFlags_RouteFromRootWindow", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// Option: route evaluated from the point of view of root window rather than current window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1729 + } + }, + { + "name": "ImGuiInputFlags_Tooltip", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "preceding": [ + "// Flags for SetNextItemShortcut()" + ], + "attached": "// Automatically display a tooltip when hovering item [BETA] Unsure of right api (opt-in/opt-out)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1732 + } + } + ], + "comments": { + "preceding": [ + "// Flags for Shortcut(), SetNextItemShortcut(),", + "// (and for upcoming extended versions of IsKeyPressed(), IsMouseClicked(), Shortcut(), SetKeyOwner(), SetItemKeyOwner() that are still in imgui_internal.h)", + "// Don't mistake with ImGuiInputTextFlags! (which is for ImGui::InputText() function)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1713 + } + }, + { + "name": "ImGuiConfigFlags_", + "original_fully_qualified_name": "ImGuiConfigFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiConfigFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1738 + } + }, + { + "name": "ImGuiConfigFlags_NavEnableKeyboard", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Master keyboard navigation enable flag. Enable full Tabbing + directional arrows + space/enter to activate." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1739 + } + }, + { + "name": "ImGuiConfigFlags_NavEnableGamepad", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Master gamepad navigation enable flag. Backend also needs to set ImGuiBackendFlags_HasGamepad." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1740 + } + }, + { + "name": "ImGuiConfigFlags_NoMouse", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Instruct dear imgui to disable mouse inputs and interactions." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1741 + } + }, + { + "name": "ImGuiConfigFlags_NoMouseCursorChange", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Instruct backend to not alter mouse cursor shape and visibility. Use if the backend cursor changes are interfering with yours and you don't want to use SetMouseCursor() to change mouse cursor. You may want to honor requests from imgui by reading GetMouseCursor() yourself instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1742 + } + }, + { + "name": "ImGuiConfigFlags_NoKeyboard", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Instruct dear imgui to disable keyboard inputs and interactions. This is done by ignoring keyboard events and clearing existing states." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1743 + } + }, + { + "name": "ImGuiConfigFlags_DockingEnable", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "preceding": [ + "// [BETA] Docking" + ], + "attached": "// Docking enable flags." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1746 + } + }, + { + "name": "ImGuiConfigFlags_ViewportsEnable", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "preceding": [ + "// [BETA] Viewports", + "// When using viewports it is recommended that your default value for ImGuiCol_WindowBg is opaque (Alpha=1.0) so transition to a viewport won't be noticeable." + ], + "attached": "// Viewport enable flags (require both ImGuiBackendFlags_PlatformHasViewports + ImGuiBackendFlags_RendererHasViewports set by the respective backends)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1750 + } + }, + { + "name": "ImGuiConfigFlags_IsSRGB", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "preceding": [ + "// User storage (to allow your backend/engine to communicate to code that may be shared between multiple projects. Those flags are NOT used by core Dear ImGui)" + ], + "attached": "// Application is SRGB-aware." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1753 + } + }, + { + "name": "ImGuiConfigFlags_IsTouchScreen", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// Application is using a touch screen instead of a mouse." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1754 + } + }, + { + "name": "ImGuiConfigFlags_NavEnableSetMousePos", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// [moved/renamed in 1.91.4] -> use bool io.ConfigNavMoveSetMousePos" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1757 + } + }, + { + "name": "ImGuiConfigFlags_NavNoCaptureKeyboard", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// [moved/renamed in 1.91.4] -> use bool io.ConfigNavCaptureKeyboard" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1758 + } + }, + { + "name": "ImGuiConfigFlags_DpiEnableScaleFonts", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// [moved/renamed in 1.92.0] -> use bool io.ConfigDpiScaleFonts" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1759 + } + }, + { + "name": "ImGuiConfigFlags_DpiEnableScaleViewports", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// [moved/renamed in 1.92.0] -> use bool io.ConfigDpiScaleViewports" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1760 + } + } + ], + "comments": { + "preceding": [ + "// Configuration flags stored in io.ConfigFlags. Set by user/application." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1736 + } + }, + { + "name": "ImGuiBackendFlags_", + "original_fully_qualified_name": "ImGuiBackendFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiBackendFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1767 + } + }, + { + "name": "ImGuiBackendFlags_HasGamepad", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Backend Platform supports gamepad and currently has one connected." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1768 + } + }, + { + "name": "ImGuiBackendFlags_HasMouseCursors", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Backend Platform supports honoring GetMouseCursor() value to change the OS cursor shape." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1769 + } + }, + { + "name": "ImGuiBackendFlags_HasSetMousePos", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Backend Platform supports io.WantSetMousePos requests to reposition the OS mouse position (only used if io.ConfigNavMoveSetMousePos is set)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1770 + } + }, + { + "name": "ImGuiBackendFlags_RendererHasVtxOffset", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Backend Renderer supports ImDrawCmd::VtxOffset. This enables output of large meshes (64K+ vertices) while still using 16-bit indices." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1771 + } + }, + { + "name": "ImGuiBackendFlags_RendererHasTextures", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Backend Renderer supports ImTextureData requests to create/update/destroy textures. This enables incremental texture updates and texture reloads. See https://github.com/ocornut/imgui/blob/master/docs/BACKENDS.md for instructions on how to upgrade your custom backend." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1772 + } + }, + { + "name": "ImGuiBackendFlags_PlatformHasViewports", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "preceding": [ + "// [BETA] Viewports" + ], + "attached": "// Backend Platform supports multiple viewports." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1775 + } + }, + { + "name": "ImGuiBackendFlags_HasMouseHoveredViewport", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Backend Platform supports calling io.AddMouseViewportEvent() with the viewport under the mouse. IF POSSIBLE, ignore viewports with the ImGuiViewportFlags_NoInputs flag (Win32 backend, GLFW 3.30+ backend can do this, SDL backend cannot). If this cannot be done, Dear ImGui needs to use a flawed heuristic to find the viewport under." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1776 + } + }, + { + "name": "ImGuiBackendFlags_RendererHasViewports", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Backend Renderer supports multiple viewports." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1777 + } + } + ], + "comments": { + "preceding": [ + "// Backend capabilities flags stored in io.BackendFlags. Set by imgui_impl_xxx or custom backend." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1765 + } + }, + { + "name": "ImGuiCol_", + "original_fully_qualified_name": "ImGuiCol_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiCol_Text", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1783 + } + }, + { + "name": "ImGuiCol_TextDisabled", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1784 + } + }, + { + "name": "ImGuiCol_WindowBg", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Background of normal windows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1785 + } + }, + { + "name": "ImGuiCol_ChildBg", + "value": 3, + "is_count": false, + "comments": { + "attached": "// Background of child windows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1786 + } + }, + { + "name": "ImGuiCol_PopupBg", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Background of popups, menus, tooltips windows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1787 + } + }, + { + "name": "ImGuiCol_Border", + "value": 5, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1788 + } + }, + { + "name": "ImGuiCol_BorderShadow", + "value": 6, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1789 + } + }, + { + "name": "ImGuiCol_FrameBg", + "value": 7, + "is_count": false, + "comments": { + "attached": "// Background of checkbox, radio button, plot, slider, text input" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1790 + } + }, + { + "name": "ImGuiCol_FrameBgHovered", + "value": 8, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1791 + } + }, + { + "name": "ImGuiCol_FrameBgActive", + "value": 9, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1792 + } + }, + { + "name": "ImGuiCol_TitleBg", + "value": 10, + "is_count": false, + "comments": { + "attached": "// Title bar" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1793 + } + }, + { + "name": "ImGuiCol_TitleBgActive", + "value": 11, + "is_count": false, + "comments": { + "attached": "// Title bar when focused" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1794 + } + }, + { + "name": "ImGuiCol_TitleBgCollapsed", + "value": 12, + "is_count": false, + "comments": { + "attached": "// Title bar when collapsed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1795 + } + }, + { + "name": "ImGuiCol_MenuBarBg", + "value": 13, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1796 + } + }, + { + "name": "ImGuiCol_ScrollbarBg", + "value": 14, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1797 + } + }, + { + "name": "ImGuiCol_ScrollbarGrab", + "value": 15, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1798 + } + }, + { + "name": "ImGuiCol_ScrollbarGrabHovered", + "value": 16, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1799 + } + }, + { + "name": "ImGuiCol_ScrollbarGrabActive", + "value": 17, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1800 + } + }, + { + "name": "ImGuiCol_CheckMark", + "value": 18, + "is_count": false, + "comments": { + "attached": "// Checkbox tick and RadioButton circle" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1801 + } + }, + { + "name": "ImGuiCol_SliderGrab", + "value": 19, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1802 + } + }, + { + "name": "ImGuiCol_SliderGrabActive", + "value": 20, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1803 + } + }, + { + "name": "ImGuiCol_Button", + "value": 21, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1804 + } + }, + { + "name": "ImGuiCol_ButtonHovered", + "value": 22, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1805 + } + }, + { + "name": "ImGuiCol_ButtonActive", + "value": 23, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1806 + } + }, + { + "name": "ImGuiCol_Header", + "value": 24, + "is_count": false, + "comments": { + "attached": "// Header* colors are used for CollapsingHeader, TreeNode, Selectable, MenuItem" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1807 + } + }, + { + "name": "ImGuiCol_HeaderHovered", + "value": 25, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1808 + } + }, + { + "name": "ImGuiCol_HeaderActive", + "value": 26, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1809 + } + }, + { + "name": "ImGuiCol_Separator", + "value": 27, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1810 + } + }, + { + "name": "ImGuiCol_SeparatorHovered", + "value": 28, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1811 + } + }, + { + "name": "ImGuiCol_SeparatorActive", + "value": 29, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1812 + } + }, + { + "name": "ImGuiCol_ResizeGrip", + "value": 30, + "is_count": false, + "comments": { + "attached": "// Resize grip in lower-right and lower-left corners of windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1813 + } + }, + { + "name": "ImGuiCol_ResizeGripHovered", + "value": 31, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1814 + } + }, + { + "name": "ImGuiCol_ResizeGripActive", + "value": 32, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1815 + } + }, + { + "name": "ImGuiCol_InputTextCursor", + "value": 33, + "is_count": false, + "comments": { + "attached": "// InputText cursor/caret" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1816 + } + }, + { + "name": "ImGuiCol_TabHovered", + "value": 34, + "is_count": false, + "comments": { + "attached": "// Tab background, when hovered" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1817 + } + }, + { + "name": "ImGuiCol_Tab", + "value": 35, + "is_count": false, + "comments": { + "attached": "// Tab background, when tab-bar is focused & tab is unselected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1818 + } + }, + { + "name": "ImGuiCol_TabSelected", + "value": 36, + "is_count": false, + "comments": { + "attached": "// Tab background, when tab-bar is focused & tab is selected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1819 + } + }, + { + "name": "ImGuiCol_TabSelectedOverline", + "value": 37, + "is_count": false, + "comments": { + "attached": "// Tab horizontal overline, when tab-bar is focused & tab is selected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1820 + } + }, + { + "name": "ImGuiCol_TabDimmed", + "value": 38, + "is_count": false, + "comments": { + "attached": "// Tab background, when tab-bar is unfocused & tab is unselected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1821 + } + }, + { + "name": "ImGuiCol_TabDimmedSelected", + "value": 39, + "is_count": false, + "comments": { + "attached": "// Tab background, when tab-bar is unfocused & tab is selected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1822 + } + }, + { + "name": "ImGuiCol_TabDimmedSelectedOverline", + "value": 40, + "is_count": false, + "comments": { + "attached": "//..horizontal overline, when tab-bar is unfocused & tab is selected" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1823 + } + }, + { + "name": "ImGuiCol_DockingPreview", + "value": 41, + "is_count": false, + "comments": { + "attached": "// Preview overlay color when about to docking something" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1824 + } + }, + { + "name": "ImGuiCol_DockingEmptyBg", + "value": 42, + "is_count": false, + "comments": { + "attached": "// Background color for empty node (e.g. CentralNode with no window docked into it)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1825 + } + }, + { + "name": "ImGuiCol_PlotLines", + "value": 43, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1826 + } + }, + { + "name": "ImGuiCol_PlotLinesHovered", + "value": 44, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1827 + } + }, + { + "name": "ImGuiCol_PlotHistogram", + "value": 45, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1828 + } + }, + { + "name": "ImGuiCol_PlotHistogramHovered", + "value": 46, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1829 + } + }, + { + "name": "ImGuiCol_TableHeaderBg", + "value": 47, + "is_count": false, + "comments": { + "attached": "// Table header background" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1830 + } + }, + { + "name": "ImGuiCol_TableBorderStrong", + "value": 48, + "is_count": false, + "comments": { + "attached": "// Table outer and header borders (prefer using Alpha=1.0 here)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1831 + } + }, + { + "name": "ImGuiCol_TableBorderLight", + "value": 49, + "is_count": false, + "comments": { + "attached": "// Table inner borders (prefer using Alpha=1.0 here)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1832 + } + }, + { + "name": "ImGuiCol_TableRowBg", + "value": 50, + "is_count": false, + "comments": { + "attached": "// Table row background (even rows)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1833 + } + }, + { + "name": "ImGuiCol_TableRowBgAlt", + "value": 51, + "is_count": false, + "comments": { + "attached": "// Table row background (odd rows)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1834 + } + }, + { + "name": "ImGuiCol_TextLink", + "value": 52, + "is_count": false, + "comments": { + "attached": "// Hyperlink color" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1835 + } + }, + { + "name": "ImGuiCol_TextSelectedBg", + "value": 53, + "is_count": false, + "comments": { + "attached": "// Selected text inside an InputText" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1836 + } + }, + { + "name": "ImGuiCol_TreeLines", + "value": 54, + "is_count": false, + "comments": { + "attached": "// Tree node hierarchy outlines when using ImGuiTreeNodeFlags_DrawLines" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1837 + } + }, + { + "name": "ImGuiCol_DragDropTarget", + "value": 55, + "is_count": false, + "comments": { + "attached": "// Rectangle highlighting a drop target" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1838 + } + }, + { + "name": "ImGuiCol_NavCursor", + "value": 56, + "is_count": false, + "comments": { + "attached": "// Color of keyboard/gamepad navigation cursor/rectangle, when visible" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1839 + } + }, + { + "name": "ImGuiCol_NavWindowingHighlight", + "value": 57, + "is_count": false, + "comments": { + "attached": "// Highlight window when using CTRL+TAB" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1840 + } + }, + { + "name": "ImGuiCol_NavWindowingDimBg", + "value": 58, + "is_count": false, + "comments": { + "attached": "// Darken/colorize entire screen behind the CTRL+TAB window list, when active" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1841 + } + }, + { + "name": "ImGuiCol_ModalWindowDimBg", + "value": 59, + "is_count": false, + "comments": { + "attached": "// Darken/colorize entire screen behind a modal window, when one is active" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1842 + } + }, + { + "name": "ImGuiCol_COUNT", + "value": 60, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1843 + } + }, + { + "name": "ImGuiCol_TabActive", + "value_expression": "ImGuiCol_TabSelected", + "value": 36, + "is_count": false, + "comments": { + "attached": "// [renamed in 1.90.9]" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1846 + } + }, + { + "name": "ImGuiCol_TabUnfocused", + "value_expression": "ImGuiCol_TabDimmed", + "value": 38, + "is_count": false, + "comments": { + "attached": "// [renamed in 1.90.9]" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1847 + } + }, + { + "name": "ImGuiCol_TabUnfocusedActive", + "value_expression": "ImGuiCol_TabDimmedSelected", + "value": 39, + "is_count": false, + "comments": { + "attached": "// [renamed in 1.90.9]" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1848 + } + }, + { + "name": "ImGuiCol_NavHighlight", + "value_expression": "ImGuiCol_NavCursor", + "value": 56, + "is_count": false, + "comments": { + "attached": "// [renamed in 1.91.4]" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1849 + } + } + ], + "comments": { + "preceding": [ + "// Enumeration for PushStyleColor() / PopStyleColor()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1781 + } + }, + { + "name": "ImGuiStyleVar_", + "original_fully_qualified_name": "ImGuiStyleVar_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiStyleVar_Alpha", + "value": 0, + "is_count": false, + "comments": { + "preceding": [ + "// Enum name -------------------------- // Member in ImGuiStyle structure (see ImGuiStyle for descriptions)" + ], + "attached": "// float Alpha" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1864 + } + }, + { + "name": "ImGuiStyleVar_DisabledAlpha", + "value": 1, + "is_count": false, + "comments": { + "attached": "// float DisabledAlpha" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1865 + } + }, + { + "name": "ImGuiStyleVar_WindowPadding", + "value": 2, + "is_count": false, + "comments": { + "attached": "// ImVec2 WindowPadding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1866 + } + }, + { + "name": "ImGuiStyleVar_WindowRounding", + "value": 3, + "is_count": false, + "comments": { + "attached": "// float WindowRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1867 + } + }, + { + "name": "ImGuiStyleVar_WindowBorderSize", + "value": 4, + "is_count": false, + "comments": { + "attached": "// float WindowBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1868 + } + }, + { + "name": "ImGuiStyleVar_WindowMinSize", + "value": 5, + "is_count": false, + "comments": { + "attached": "// ImVec2 WindowMinSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1869 + } + }, + { + "name": "ImGuiStyleVar_WindowTitleAlign", + "value": 6, + "is_count": false, + "comments": { + "attached": "// ImVec2 WindowTitleAlign" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1870 + } + }, + { + "name": "ImGuiStyleVar_ChildRounding", + "value": 7, + "is_count": false, + "comments": { + "attached": "// float ChildRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1871 + } + }, + { + "name": "ImGuiStyleVar_ChildBorderSize", + "value": 8, + "is_count": false, + "comments": { + "attached": "// float ChildBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1872 + } + }, + { + "name": "ImGuiStyleVar_PopupRounding", + "value": 9, + "is_count": false, + "comments": { + "attached": "// float PopupRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1873 + } + }, + { + "name": "ImGuiStyleVar_PopupBorderSize", + "value": 10, + "is_count": false, + "comments": { + "attached": "// float PopupBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1874 + } + }, + { + "name": "ImGuiStyleVar_FramePadding", + "value": 11, + "is_count": false, + "comments": { + "attached": "// ImVec2 FramePadding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1875 + } + }, + { + "name": "ImGuiStyleVar_FrameRounding", + "value": 12, + "is_count": false, + "comments": { + "attached": "// float FrameRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1876 + } + }, + { + "name": "ImGuiStyleVar_FrameBorderSize", + "value": 13, + "is_count": false, + "comments": { + "attached": "// float FrameBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1877 + } + }, + { + "name": "ImGuiStyleVar_ItemSpacing", + "value": 14, + "is_count": false, + "comments": { + "attached": "// ImVec2 ItemSpacing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1878 + } + }, + { + "name": "ImGuiStyleVar_ItemInnerSpacing", + "value": 15, + "is_count": false, + "comments": { + "attached": "// ImVec2 ItemInnerSpacing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1879 + } + }, + { + "name": "ImGuiStyleVar_IndentSpacing", + "value": 16, + "is_count": false, + "comments": { + "attached": "// float IndentSpacing" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1880 + } + }, + { + "name": "ImGuiStyleVar_CellPadding", + "value": 17, + "is_count": false, + "comments": { + "attached": "// ImVec2 CellPadding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1881 + } + }, + { + "name": "ImGuiStyleVar_ScrollbarSize", + "value": 18, + "is_count": false, + "comments": { + "attached": "// float ScrollbarSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1882 + } + }, + { + "name": "ImGuiStyleVar_ScrollbarRounding", + "value": 19, + "is_count": false, + "comments": { + "attached": "// float ScrollbarRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1883 + } + }, + { + "name": "ImGuiStyleVar_GrabMinSize", + "value": 20, + "is_count": false, + "comments": { + "attached": "// float GrabMinSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1884 + } + }, + { + "name": "ImGuiStyleVar_GrabRounding", + "value": 21, + "is_count": false, + "comments": { + "attached": "// float GrabRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1885 + } + }, + { + "name": "ImGuiStyleVar_ImageBorderSize", + "value": 22, + "is_count": false, + "comments": { + "attached": "// float ImageBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1886 + } + }, + { + "name": "ImGuiStyleVar_TabRounding", + "value": 23, + "is_count": false, + "comments": { + "attached": "// float TabRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1887 + } + }, + { + "name": "ImGuiStyleVar_TabBorderSize", + "value": 24, + "is_count": false, + "comments": { + "attached": "// float TabBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1888 + } + }, + { + "name": "ImGuiStyleVar_TabMinWidthBase", + "value": 25, + "is_count": false, + "comments": { + "attached": "// float TabMinWidthBase" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1889 + } + }, + { + "name": "ImGuiStyleVar_TabMinWidthShrink", + "value": 26, + "is_count": false, + "comments": { + "attached": "// float TabMinWidthShrink" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1890 + } + }, + { + "name": "ImGuiStyleVar_TabBarBorderSize", + "value": 27, + "is_count": false, + "comments": { + "attached": "// float TabBarBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1891 + } + }, + { + "name": "ImGuiStyleVar_TabBarOverlineSize", + "value": 28, + "is_count": false, + "comments": { + "attached": "// float TabBarOverlineSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1892 + } + }, + { + "name": "ImGuiStyleVar_TableAngledHeadersAngle", + "value": 29, + "is_count": false, + "comments": { + "attached": "// float TableAngledHeadersAngle" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1893 + } + }, + { + "name": "ImGuiStyleVar_TableAngledHeadersTextAlign", + "value": 30, + "is_count": false, + "comments": { + "attached": "// ImVec2 TableAngledHeadersTextAlign" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1894 + } + }, + { + "name": "ImGuiStyleVar_TreeLinesSize", + "value": 31, + "is_count": false, + "comments": { + "attached": "// float TreeLinesSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1895 + } + }, + { + "name": "ImGuiStyleVar_TreeLinesRounding", + "value": 32, + "is_count": false, + "comments": { + "attached": "// float TreeLinesRounding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1896 + } + }, + { + "name": "ImGuiStyleVar_ButtonTextAlign", + "value": 33, + "is_count": false, + "comments": { + "attached": "// ImVec2 ButtonTextAlign" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1897 + } + }, + { + "name": "ImGuiStyleVar_SelectableTextAlign", + "value": 34, + "is_count": false, + "comments": { + "attached": "// ImVec2 SelectableTextAlign" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1898 + } + }, + { + "name": "ImGuiStyleVar_SeparatorTextBorderSize", + "value": 35, + "is_count": false, + "comments": { + "attached": "// float SeparatorTextBorderSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1899 + } + }, + { + "name": "ImGuiStyleVar_SeparatorTextAlign", + "value": 36, + "is_count": false, + "comments": { + "attached": "// ImVec2 SeparatorTextAlign" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1900 + } + }, + { + "name": "ImGuiStyleVar_SeparatorTextPadding", + "value": 37, + "is_count": false, + "comments": { + "attached": "// ImVec2 SeparatorTextPadding" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1901 + } + }, + { + "name": "ImGuiStyleVar_DockingSeparatorSize", + "value": 38, + "is_count": false, + "comments": { + "attached": "// float DockingSeparatorSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1902 + } + }, + { + "name": "ImGuiStyleVar_COUNT", + "value": 39, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1903 + } + } + ], + "comments": { + "preceding": [ + "// Enumeration for PushStyleVar() / PopStyleVar() to temporarily modify the ImGuiStyle structure.", + "// - The enum only refers to fields of ImGuiStyle which makes sense to be pushed/popped inside UI code.", + "// During initialization or between frames, feel free to just poke into ImGuiStyle directly.", + "// - Tip: Use your programming IDE navigation facilities on the names in the _second column_ below to find the actual members and their description.", + "// - In Visual Studio: CTRL+comma (\"Edit.GoToAll\") can follow symbols inside comments, whereas CTRL+F12 (\"Edit.GoToImplementation\") cannot.", + "// - In Visual Studio w/ Visual Assist installed: ALT+G (\"VAssistX.GoToImplementation\") can also follow symbols inside comments.", + "// - In VS Code, CLion, etc.: CTRL+click can follow symbols inside comments.", + "// - When changing this enum, you need to update the associated internal table GStyleVarInfo[] accordingly. This is where we link enum values to members offset/type." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1861 + } + }, + { + "name": "ImGuiButtonFlags_", + "original_fully_qualified_name": "ImGuiButtonFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiButtonFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1909 + } + }, + { + "name": "ImGuiButtonFlags_MouseButtonLeft", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// React on left mouse button (default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1910 + } + }, + { + "name": "ImGuiButtonFlags_MouseButtonRight", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// React on right mouse button" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1911 + } + }, + { + "name": "ImGuiButtonFlags_MouseButtonMiddle", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// React on center mouse button" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1912 + } + }, + { + "name": "ImGuiButtonFlags_MouseButtonMask_", + "value_expression": "ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight | ImGuiButtonFlags_MouseButtonMiddle", + "value": 7, + "is_count": false, + "comments": { + "attached": "// [Internal]" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1913 + } + }, + { + "name": "ImGuiButtonFlags_EnableNav", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// InvisibleButton(): do not disable navigation/tabbing. Otherwise disabled by default." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1914 + } + } + ], + "comments": { + "preceding": [ + "// Flags for InvisibleButton() [extended in imgui_internal.h]" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1907 + } + }, + { + "name": "ImGuiColorEditFlags_", + "original_fully_qualified_name": "ImGuiColorEditFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiColorEditFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1920 + } + }, + { + "name": "ImGuiColorEditFlags_NoAlpha", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// // ColorEdit, ColorPicker, ColorButton: ignore Alpha component (will only read 3 components from the input pointer)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1921 + } + }, + { + "name": "ImGuiColorEditFlags_NoPicker", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// // ColorEdit: disable picker when clicking on color square." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1922 + } + }, + { + "name": "ImGuiColorEditFlags_NoOptions", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// // ColorEdit: disable toggling options menu when right-clicking on inputs/small preview." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1923 + } + }, + { + "name": "ImGuiColorEditFlags_NoSmallPreview", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// // ColorEdit, ColorPicker: disable color square preview next to the inputs. (e.g. to show only the inputs)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1924 + } + }, + { + "name": "ImGuiColorEditFlags_NoInputs", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// // ColorEdit, ColorPicker: disable inputs sliders/text widgets (e.g. to show only the small preview color square)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1925 + } + }, + { + "name": "ImGuiColorEditFlags_NoTooltip", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// // ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1926 + } + }, + { + "name": "ImGuiColorEditFlags_NoLabel", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// // ColorEdit, ColorPicker: disable display of inline text label (the label is still forwarded to the tooltip and picker)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1927 + } + }, + { + "name": "ImGuiColorEditFlags_NoSidePreview", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// // ColorPicker: disable bigger color preview on right side of the picker, use small color square preview instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1928 + } + }, + { + "name": "ImGuiColorEditFlags_NoDragDrop", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// // ColorEdit: disable drag and drop target. ColorButton: disable drag and drop source." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1929 + } + }, + { + "name": "ImGuiColorEditFlags_NoBorder", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// // ColorButton: disable border (which is enforced by default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1930 + } + }, + { + "name": "ImGuiColorEditFlags_AlphaOpaque", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "preceding": [ + "// Alpha preview", + "// - Prior to 1.91.8 (2025/01/21): alpha was made opaque in the preview by default using old name ImGuiColorEditFlags_AlphaPreview.", + "// - We now display the preview as transparent by default. You can use ImGuiColorEditFlags_AlphaOpaque to use old behavior.", + "// - The new flags may be combined better and allow finer controls." + ], + "attached": "// // ColorEdit, ColorPicker, ColorButton: disable alpha in the preview,. Contrary to _NoAlpha it may still be edited when calling ColorEdit4()/ColorPicker4(). For ColorButton() this does the same as _NoAlpha." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1936 + } + }, + { + "name": "ImGuiColorEditFlags_AlphaNoBg", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// // ColorEdit, ColorPicker, ColorButton: disable rendering a checkerboard background behind transparent color." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1937 + } + }, + { + "name": "ImGuiColorEditFlags_AlphaPreviewHalf", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// // ColorEdit, ColorPicker, ColorButton: display half opaque / half transparent preview." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1938 + } + }, + { + "name": "ImGuiColorEditFlags_AlphaBar", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "preceding": [ + "// User Options (right-click on widget to change some of them)." + ], + "attached": "// // ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1941 + } + }, + { + "name": "ImGuiColorEditFlags_HDR", + "value_expression": "1<<19", + "value": 524288, + "is_count": false, + "comments": { + "attached": "// // (WIP) ColorEdit: Currently only disable 0.0f..1.0f limits in RGBA edition (note: you probably want to use ImGuiColorEditFlags_Float flag as well)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1942 + } + }, + { + "name": "ImGuiColorEditFlags_DisplayRGB", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "attached": "// [Display] // ColorEdit: override _display_ type among RGB/HSV/Hex. ColorPicker: select any combination using one or more of RGB/HSV/Hex." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1943 + } + }, + { + "name": "ImGuiColorEditFlags_DisplayHSV", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "attached": "// [Display] // \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1944 + } + }, + { + "name": "ImGuiColorEditFlags_DisplayHex", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// [Display] // \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1945 + } + }, + { + "name": "ImGuiColorEditFlags_Uint8", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "attached": "// [DataType] // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1946 + } + }, + { + "name": "ImGuiColorEditFlags_Float", + "value_expression": "1<<24", + "value": 16777216, + "is_count": false, + "comments": { + "attached": "// [DataType] // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0f..1.0f floats instead of 0..255 integers. No round-trip of value via integers." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1947 + } + }, + { + "name": "ImGuiColorEditFlags_PickerHueBar", + "value_expression": "1<<25", + "value": 33554432, + "is_count": false, + "comments": { + "attached": "// [Picker] // ColorPicker: bar for Hue, rectangle for Sat/Value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1948 + } + }, + { + "name": "ImGuiColorEditFlags_PickerHueWheel", + "value_expression": "1<<26", + "value": 67108864, + "is_count": false, + "comments": { + "attached": "// [Picker] // ColorPicker: wheel for Hue, triangle for Sat/Value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1949 + } + }, + { + "name": "ImGuiColorEditFlags_InputRGB", + "value_expression": "1<<27", + "value": 134217728, + "is_count": false, + "comments": { + "attached": "// [Input] // ColorEdit, ColorPicker: input and output data in RGB format." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1950 + } + }, + { + "name": "ImGuiColorEditFlags_InputHSV", + "value_expression": "1<<28", + "value": 268435456, + "is_count": false, + "comments": { + "attached": "// [Input] // ColorEdit, ColorPicker: input and output data in HSV format." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1951 + } + }, + { + "name": "ImGuiColorEditFlags_DefaultOptions_", + "value_expression": "ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_PickerHueBar", + "value": 177209344, + "is_count": false, + "comments": { + "preceding": [ + "// Defaults Options. You can set application defaults using SetColorEditOptions(). The intent is that you probably don't want to", + "// override them in most of your calls. Let the user choose via the option menu and/or call SetColorEditOptions() once during startup." + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1955 + } + }, + { + "name": "ImGuiColorEditFlags_AlphaMask_", + "value_expression": "ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaOpaque | ImGuiColorEditFlags_AlphaNoBg | ImGuiColorEditFlags_AlphaPreviewHalf", + "value": 14338, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal] Masks" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1958 + } + }, + { + "name": "ImGuiColorEditFlags_DisplayMask_", + "value_expression": "ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV | ImGuiColorEditFlags_DisplayHex", + "value": 7340032, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1959 + } + }, + { + "name": "ImGuiColorEditFlags_DataTypeMask_", + "value_expression": "ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_Float", + "value": 25165824, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1960 + } + }, + { + "name": "ImGuiColorEditFlags_PickerMask_", + "value_expression": "ImGuiColorEditFlags_PickerHueWheel | ImGuiColorEditFlags_PickerHueBar", + "value": 100663296, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1961 + } + }, + { + "name": "ImGuiColorEditFlags_InputMask_", + "value_expression": "ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_InputHSV", + "value": 402653184, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1962 + } + }, + { + "name": "ImGuiColorEditFlags_AlphaPreview", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "attached": "// [Removed in 1.91.8] This is the default now. Will display a checkerboard unless ImGuiColorEditFlags_AlphaNoBg is set." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1966 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ColorEdit3() / ColorEdit4() / ColorPicker3() / ColorPicker4() / ColorButton()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1918 + } + }, + { + "name": "ImGuiSliderFlags_", + "original_fully_qualified_name": "ImGuiSliderFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiSliderFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1976 + } + }, + { + "name": "ImGuiSliderFlags_Logarithmic", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Make the widget logarithmic (linear otherwise). Consider using ImGuiSliderFlags_NoRoundToFormat with this if using a format-string with small amount of digits." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1977 + } + }, + { + "name": "ImGuiSliderFlags_NoRoundToFormat", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Disable rounding underlying value to match precision of the display format string (e.g. %.3f values are rounded to those 3 digits)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1978 + } + }, + { + "name": "ImGuiSliderFlags_NoInput", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Disable CTRL+Click or Enter key allowing to input text directly into the widget." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1979 + } + }, + { + "name": "ImGuiSliderFlags_WrapAround", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Enable wrapping around from max to min and from min to max. Only supported by DragXXX() functions for now." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1980 + } + }, + { + "name": "ImGuiSliderFlags_ClampOnInput", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Clamp value to min/max bounds when input manually with CTRL+Click. By default CTRL+Click allows going out of bounds." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1981 + } + }, + { + "name": "ImGuiSliderFlags_ClampZeroRange", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Clamp even if min==max==0.0f. Otherwise due to legacy reason DragXXX functions don't clamp with those values. When your clamping limits are dynamic you almost always want to use it." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1982 + } + }, + { + "name": "ImGuiSliderFlags_NoSpeedTweaks", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Disable keyboard modifiers altering tweak speed. Useful if you want to alter tweak speed yourself based on your own logic." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1983 + } + }, + { + "name": "ImGuiSliderFlags_AlwaysClamp", + "value_expression": "ImGuiSliderFlags_ClampOnInput | ImGuiSliderFlags_ClampZeroRange", + "value": 1536, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1984 + } + }, + { + "name": "ImGuiSliderFlags_InvalidMask_", + "value_expression": "0x7000000F", + "value": 1879048207, + "is_count": false, + "comments": { + "attached": "// [Internal] We treat using those bits as being potentially a 'float power' argument from the previous API that has got miscast to this enum, and will trigger an assert if needed." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 1985 + } + } + ], + "comments": { + "preceding": [ + "// Flags for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc.", + "// We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.", + "// (Those are per-item flags. There is shared behavior flag too: ImGuiIO: io.ConfigDragClickToInputText)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1974 + } + }, + { + "name": "ImGuiMouseButton_", + "original_fully_qualified_name": "ImGuiMouseButton_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiMouseButton_Left", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1992 + } + }, + { + "name": "ImGuiMouseButton_Right", + "value_expression": "1", + "value": 1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1993 + } + }, + { + "name": "ImGuiMouseButton_Middle", + "value_expression": "2", + "value": 2, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1994 + } + }, + { + "name": "ImGuiMouseButton_COUNT", + "value_expression": "5", + "value": 5, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1995 + } + } + ], + "comments": { + "preceding": [ + "// Identify a mouse button.", + "// Those values are guaranteed to be stable and we frequently use 0/1 directly. Named enums provided for convenience." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1990 + } + }, + { + "name": "ImGuiMouseCursor_", + "original_fully_qualified_name": "ImGuiMouseCursor_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiMouseCursor_None", + "value_expression": "-1", + "value": -1, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2002 + } + }, + { + "name": "ImGuiMouseCursor_Arrow", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2003 + } + }, + { + "name": "ImGuiMouseCursor_TextInput", + "value": 1, + "is_count": false, + "comments": { + "attached": "// When hovering over InputText, etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2004 + } + }, + { + "name": "ImGuiMouseCursor_ResizeAll", + "value": 2, + "is_count": false, + "comments": { + "attached": "// (Unused by Dear ImGui functions)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2005 + } + }, + { + "name": "ImGuiMouseCursor_ResizeNS", + "value": 3, + "is_count": false, + "comments": { + "attached": "// When hovering over a horizontal border" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2006 + } + }, + { + "name": "ImGuiMouseCursor_ResizeEW", + "value": 4, + "is_count": false, + "comments": { + "attached": "// When hovering over a vertical border or a column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2007 + } + }, + { + "name": "ImGuiMouseCursor_ResizeNESW", + "value": 5, + "is_count": false, + "comments": { + "attached": "// When hovering over the bottom-left corner of a window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2008 + } + }, + { + "name": "ImGuiMouseCursor_ResizeNWSE", + "value": 6, + "is_count": false, + "comments": { + "attached": "// When hovering over the bottom-right corner of a window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2009 + } + }, + { + "name": "ImGuiMouseCursor_Hand", + "value": 7, + "is_count": false, + "comments": { + "attached": "// (Unused by Dear ImGui functions. Use for e.g. hyperlinks)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2010 + } + }, + { + "name": "ImGuiMouseCursor_Wait", + "value": 8, + "is_count": false, + "comments": { + "attached": "// When waiting for something to process/load." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2011 + } + }, + { + "name": "ImGuiMouseCursor_Progress", + "value": 9, + "is_count": false, + "comments": { + "attached": "// When waiting for something to process/load, but application is still interactive." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2012 + } + }, + { + "name": "ImGuiMouseCursor_NotAllowed", + "value": 10, + "is_count": false, + "comments": { + "attached": "// When hovering something with disallowed interaction. Usually a crossed circle." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2013 + } + }, + { + "name": "ImGuiMouseCursor_COUNT", + "value": 11, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2014 + } + } + ], + "comments": { + "preceding": [ + "// Enumeration for GetMouseCursor()", + "// User code may request backend to display given cursor by calling SetMouseCursor(), which is why we have some cursors that are marked unused here" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2000 + } + }, + { + "name": "ImGuiMouseSource", + "original_fully_qualified_name": "ImGuiMouseSource", + "storage_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiMouseSource_Mouse", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "attached": "// Input is coming from an actual mouse." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2023 + } + }, + { + "name": "ImGuiMouseSource_TouchScreen", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Input is coming from a touch screen (no hovering prior to initial press, less precise initial press aiming, dual-axis wheeling possible)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2024 + } + }, + { + "name": "ImGuiMouseSource_Pen", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Input is coming from a pressure/magnetic pen (often used in conjunction with high-sampling rates)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2025 + } + }, + { + "name": "ImGuiMouseSource_COUNT", + "value": 3, + "is_count": true, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2026 + } + } + ], + "comments": { + "preceding": [ + "// Enumeration for AddMouseSourceEvent() actual source of Mouse Input data.", + "// Historically we use \"Mouse\" terminology everywhere to indicate pointer data, e.g. MousePos, IsMousePressed(), io.AddMousePosEvent()", + "// But that \"Mouse\" data can come from different source which occasionally may be useful for application to know about.", + "// You can submit a change of pointer type using io.AddMouseSourceEvent()." + ], + "attached": "// Forward declared enum type ImGuiMouseSource" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2021 + } + }, + { + "name": "ImGuiCond_", + "original_fully_qualified_name": "ImGuiCond_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiCond_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "attached": "// No condition (always set the variable), same as _Always" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2034 + } + }, + { + "name": "ImGuiCond_Always", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// No condition (always set the variable), same as _None" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2035 + } + }, + { + "name": "ImGuiCond_Once", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Set the variable once per runtime session (only the first call will succeed)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2036 + } + }, + { + "name": "ImGuiCond_FirstUseEver", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Set the variable if the object/window has no persistently saved data (no entry in .ini file)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2037 + } + }, + { + "name": "ImGuiCond_Appearing", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Set the variable if the object/window is appearing after being hidden/inactive (or the first time)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2038 + } + } + ], + "comments": { + "preceding": [ + "// Enumeration for ImGui::SetNextWindow***(), SetWindow***(), SetNextItem***() functions", + "// Represent a condition.", + "// Important: Treat as a regular enum! Do NOT combine multiple values using binary operators! All the functions above treat 0 as a shortcut to ImGuiCond_Always." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2032 + } + }, + { + "name": "ImGuiTableFlags_", + "original_fully_qualified_name": "ImGuiTableFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTableFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "preceding": [ + "// Features" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2070 + } + }, + { + "name": "ImGuiTableFlags_Resizable", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Enable resizing columns." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2071 + } + }, + { + "name": "ImGuiTableFlags_Reorderable", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Enable reordering columns in header row (need calling TableSetupColumn() + TableHeadersRow() to display headers)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2072 + } + }, + { + "name": "ImGuiTableFlags_Hideable", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Enable hiding/disabling columns in context menu." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2073 + } + }, + { + "name": "ImGuiTableFlags_Sortable", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Enable sorting. Call TableGetSortSpecs() to obtain sort specs. Also see ImGuiTableFlags_SortMulti and ImGuiTableFlags_SortTristate." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2074 + } + }, + { + "name": "ImGuiTableFlags_NoSavedSettings", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Disable persisting columns order, width and sort settings in the .ini file." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2075 + } + }, + { + "name": "ImGuiTableFlags_ContextMenuInBody", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Right-click on columns body/contents will display table context menu. By default it is available in TableHeadersRow()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2076 + } + }, + { + "name": "ImGuiTableFlags_RowBg", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "preceding": [ + "// Decorations" + ], + "attached": "// Set each RowBg color with ImGuiCol_TableRowBg or ImGuiCol_TableRowBgAlt (equivalent of calling TableSetBgColor with ImGuiTableBgFlags_RowBg0 on each row manually)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2078 + } + }, + { + "name": "ImGuiTableFlags_BordersInnerH", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Draw horizontal borders between rows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2079 + } + }, + { + "name": "ImGuiTableFlags_BordersOuterH", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Draw horizontal borders at the top and bottom." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2080 + } + }, + { + "name": "ImGuiTableFlags_BordersInnerV", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Draw vertical borders between columns." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2081 + } + }, + { + "name": "ImGuiTableFlags_BordersOuterV", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Draw vertical borders on the left and right sides." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2082 + } + }, + { + "name": "ImGuiTableFlags_BordersH", + "value_expression": "ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_BordersOuterH", + "value": 384, + "is_count": false, + "comments": { + "attached": "// Draw horizontal borders." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2083 + } + }, + { + "name": "ImGuiTableFlags_BordersV", + "value_expression": "ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_BordersOuterV", + "value": 1536, + "is_count": false, + "comments": { + "attached": "// Draw vertical borders." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2084 + } + }, + { + "name": "ImGuiTableFlags_BordersInner", + "value_expression": "ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_BordersInnerH", + "value": 640, + "is_count": false, + "comments": { + "attached": "// Draw inner borders." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2085 + } + }, + { + "name": "ImGuiTableFlags_BordersOuter", + "value_expression": "ImGuiTableFlags_BordersOuterV | ImGuiTableFlags_BordersOuterH", + "value": 1280, + "is_count": false, + "comments": { + "attached": "// Draw outer borders." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2086 + } + }, + { + "name": "ImGuiTableFlags_Borders", + "value_expression": "ImGuiTableFlags_BordersInner | ImGuiTableFlags_BordersOuter", + "value": 1920, + "is_count": false, + "comments": { + "attached": "// Draw all borders." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2087 + } + }, + { + "name": "ImGuiTableFlags_NoBordersInBody", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// [ALPHA] Disable vertical borders in columns Body (borders will always appear in Headers). -> May move to style" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2088 + } + }, + { + "name": "ImGuiTableFlags_NoBordersInBodyUntilResize", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// [ALPHA] Disable vertical borders in columns Body until hovered for resize (borders will always appear in Headers). -> May move to style" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2089 + } + }, + { + "name": "ImGuiTableFlags_SizingFixedFit", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "preceding": [ + "// Sizing Policy (read above for defaults)" + ], + "attached": "// Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching contents width." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2091 + } + }, + { + "name": "ImGuiTableFlags_SizingFixedSame", + "value_expression": "2<<13", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching the maximum contents width of all columns. Implicitly enable ImGuiTableFlags_NoKeepColumnsVisible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2092 + } + }, + { + "name": "ImGuiTableFlags_SizingStretchProp", + "value_expression": "3<<13", + "value": 24576, + "is_count": false, + "comments": { + "attached": "// Columns default to _WidthStretch with default weights proportional to each columns contents widths." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2093 + } + }, + { + "name": "ImGuiTableFlags_SizingStretchSame", + "value_expression": "4<<13", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Columns default to _WidthStretch with default weights all equal, unless overridden by TableSetupColumn()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2094 + } + }, + { + "name": "ImGuiTableFlags_NoHostExtendX", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "preceding": [ + "// Sizing Extra Options" + ], + "attached": "// Make outer width auto-fit to columns, overriding outer_size.x value. Only available when ScrollX/ScrollY are disabled and Stretch columns are not used." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2096 + } + }, + { + "name": "ImGuiTableFlags_NoHostExtendY", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// Make outer height stop exactly at outer_size.y (prevent auto-extending table past the limit). Only available when ScrollX/ScrollY are disabled. Data below the limit will be clipped and not visible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2097 + } + }, + { + "name": "ImGuiTableFlags_NoKeepColumnsVisible", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "attached": "// Disable keeping column always minimally visible when ScrollX is off and table gets too small. Not recommended if columns are resizable." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2098 + } + }, + { + "name": "ImGuiTableFlags_PreciseWidths", + "value_expression": "1<<19", + "value": 524288, + "is_count": false, + "comments": { + "attached": "// Disable distributing remainder width to stretched columns (width allocation on a 100-wide table with 3 columns: Without this flag: 33,33,34. With this flag: 33,33,33). With larger number of columns, resizing will appear to be less smooth." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2099 + } + }, + { + "name": "ImGuiTableFlags_NoClip", + "value_expression": "1<<20", + "value": 1048576, + "is_count": false, + "comments": { + "preceding": [ + "// Clipping" + ], + "attached": "// Disable clipping rectangle for every individual columns (reduce draw command count, items will be able to overflow into other columns). Generally incompatible with TableSetupScrollFreeze()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2101 + } + }, + { + "name": "ImGuiTableFlags_PadOuterX", + "value_expression": "1<<21", + "value": 2097152, + "is_count": false, + "comments": { + "preceding": [ + "// Padding" + ], + "attached": "// Default if BordersOuterV is on. Enable outermost padding. Generally desirable if you have headers." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2103 + } + }, + { + "name": "ImGuiTableFlags_NoPadOuterX", + "value_expression": "1<<22", + "value": 4194304, + "is_count": false, + "comments": { + "attached": "// Default if BordersOuterV is off. Disable outermost padding." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2104 + } + }, + { + "name": "ImGuiTableFlags_NoPadInnerX", + "value_expression": "1<<23", + "value": 8388608, + "is_count": false, + "comments": { + "attached": "// Disable inner padding between columns (double inner padding if BordersOuterV is on, single inner padding if BordersOuterV is off)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2105 + } + }, + { + "name": "ImGuiTableFlags_ScrollX", + "value_expression": "1<<24", + "value": 16777216, + "is_count": false, + "comments": { + "preceding": [ + "// Scrolling" + ], + "attached": "// Enable horizontal scrolling. Require 'outer_size' parameter of BeginTable() to specify the container size. Changes default sizing policy. Because this creates a child window, ScrollY is currently generally recommended when using ScrollX." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2107 + } + }, + { + "name": "ImGuiTableFlags_ScrollY", + "value_expression": "1<<25", + "value": 33554432, + "is_count": false, + "comments": { + "attached": "// Enable vertical scrolling. Require 'outer_size' parameter of BeginTable() to specify the container size." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2108 + } + }, + { + "name": "ImGuiTableFlags_SortMulti", + "value_expression": "1<<26", + "value": 67108864, + "is_count": false, + "comments": { + "preceding": [ + "// Sorting" + ], + "attached": "// Hold shift when clicking headers to sort on multiple column. TableGetSortSpecs() may return specs where (SpecsCount > 1)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2110 + } + }, + { + "name": "ImGuiTableFlags_SortTristate", + "value_expression": "1<<27", + "value": 134217728, + "is_count": false, + "comments": { + "attached": "// Allow no sorting, disable default sorting. TableGetSortSpecs() may return specs where (SpecsCount == 0)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2111 + } + }, + { + "name": "ImGuiTableFlags_HighlightHoveredColumn", + "value_expression": "1<<28", + "value": 268435456, + "is_count": false, + "comments": { + "preceding": [ + "// Miscellaneous" + ], + "attached": "// Highlight column headers when hovered (may evolve into a fuller highlight)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2113 + } + }, + { + "name": "ImGuiTableFlags_SizingMask_", + "value_expression": "ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_SizingFixedSame | ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_SizingStretchSame", + "value": 57344, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal] Combinations and masks" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2116 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::BeginTable()", + "// - Important! Sizing policies have complex and subtle side effects, much more so than you would expect.", + "// Read comments/demos carefully + experiment with live demos to get acquainted with them.", + "// - The DEFAULT sizing policies are:", + "// - Default to ImGuiTableFlags_SizingFixedFit if ScrollX is on, or if host window has ImGuiWindowFlags_AlwaysAutoResize.", + "// - Default to ImGuiTableFlags_SizingStretchSame if ScrollX is off.", + "// - When ScrollX is off:", + "// - Table defaults to ImGuiTableFlags_SizingStretchSame -> all Columns defaults to ImGuiTableColumnFlags_WidthStretch with same weight.", + "// - Columns sizing policy allowed: Stretch (default), Fixed/Auto.", + "// - Fixed Columns (if any) will generally obtain their requested width (unless the table cannot fit them all).", + "// - Stretch Columns will share the remaining width according to their respective weight.", + "// - Mixed Fixed/Stretch columns is possible but has various side-effects on resizing behaviors.", + "// The typical use of mixing sizing policies is: any number of LEADING Fixed columns, followed by one or two TRAILING Stretch columns.", + "// (this is because the visible order of columns have subtle but necessary effects on how they react to manual resizing).", + "// - When ScrollX is on:", + "// - Table defaults to ImGuiTableFlags_SizingFixedFit -> all Columns defaults to ImGuiTableColumnFlags_WidthFixed", + "// - Columns sizing policy allowed: Fixed/Auto mostly.", + "// - Fixed Columns can be enlarged as needed. Table will show a horizontal scrollbar if needed.", + "// - When using auto-resizing (non-resizable) fixed columns, querying the content width to use item right-alignment e.g. SetNextItemWidth(-FLT_MIN) doesn't make sense, would create a feedback loop.", + "// - Using Stretch columns OFTEN DOES NOT MAKE SENSE if ScrollX is on, UNLESS you have specified a value for 'inner_width' in BeginTable().", + "// If you specify a value for 'inner_width' then effectively the scrolling space is known and Stretch or mixed Fixed/Stretch columns become meaningful again.", + "// - Read on documentation at the top of imgui_tables.cpp for details." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2067 + } + }, + { + "name": "ImGuiTableColumnFlags_", + "original_fully_qualified_name": "ImGuiTableColumnFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTableColumnFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "comments": { + "preceding": [ + "// Input configuration flags" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2123 + } + }, + { + "name": "ImGuiTableColumnFlags_Disabled", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Overriding/master disable flag: hide column, won't show in context menu (unlike calling TableSetColumnEnabled() which manipulates the user accessible state)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2124 + } + }, + { + "name": "ImGuiTableColumnFlags_DefaultHide", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Default as a hidden/disabled column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2125 + } + }, + { + "name": "ImGuiTableColumnFlags_DefaultSort", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Default as a sorting column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2126 + } + }, + { + "name": "ImGuiTableColumnFlags_WidthStretch", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Column will stretch. Preferable with horizontal scrolling disabled (default if table sizing policy is _SizingStretchSame or _SizingStretchProp)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2127 + } + }, + { + "name": "ImGuiTableColumnFlags_WidthFixed", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Column will not stretch. Preferable with horizontal scrolling enabled (default if table sizing policy is _SizingFixedFit and table is resizable)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2128 + } + }, + { + "name": "ImGuiTableColumnFlags_NoResize", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Disable manual resizing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2129 + } + }, + { + "name": "ImGuiTableColumnFlags_NoReorder", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Disable manual reordering this column, this will also prevent other columns from crossing over this column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2130 + } + }, + { + "name": "ImGuiTableColumnFlags_NoHide", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Disable ability to hide/disable this column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2131 + } + }, + { + "name": "ImGuiTableColumnFlags_NoClip", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Disable clipping for this column (all NoClip columns will render in a same draw command)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2132 + } + }, + { + "name": "ImGuiTableColumnFlags_NoSort", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Disable ability to sort on this field (even if ImGuiTableFlags_Sortable is set on the table)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2133 + } + }, + { + "name": "ImGuiTableColumnFlags_NoSortAscending", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Disable ability to sort in the ascending direction." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2134 + } + }, + { + "name": "ImGuiTableColumnFlags_NoSortDescending", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Disable ability to sort in the descending direction." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2135 + } + }, + { + "name": "ImGuiTableColumnFlags_NoHeaderLabel", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// TableHeadersRow() will submit an empty label for this column. Convenient for some small columns. Name will still appear in context menu or in angled headers. You may append into this cell by calling TableSetColumnIndex() right after the TableHeadersRow() call." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2136 + } + }, + { + "name": "ImGuiTableColumnFlags_NoHeaderWidth", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Disable header text width contribution to automatic column width." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2137 + } + }, + { + "name": "ImGuiTableColumnFlags_PreferSortAscending", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Make the initial sort direction Ascending when first sorting on this column (default)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2138 + } + }, + { + "name": "ImGuiTableColumnFlags_PreferSortDescending", + "value_expression": "1<<15", + "value": 32768, + "is_count": false, + "comments": { + "attached": "// Make the initial sort direction Descending when first sorting on this column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2139 + } + }, + { + "name": "ImGuiTableColumnFlags_IndentEnable", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "attached": "// Use current Indent value when entering cell (default for column 0)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2140 + } + }, + { + "name": "ImGuiTableColumnFlags_IndentDisable", + "value_expression": "1<<17", + "value": 131072, + "is_count": false, + "comments": { + "attached": "// Ignore current Indent value when entering cell (default for columns > 0). Indentation changes _within_ the cell will still be honored." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2141 + } + }, + { + "name": "ImGuiTableColumnFlags_AngledHeader", + "value_expression": "1<<18", + "value": 262144, + "is_count": false, + "comments": { + "attached": "// TableHeadersRow() will submit an angled header row for this column. Note this will add an extra row." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2142 + } + }, + { + "name": "ImGuiTableColumnFlags_IsEnabled", + "value_expression": "1<<24", + "value": 16777216, + "is_count": false, + "comments": { + "preceding": [ + "// Output status flags, read-only via TableGetColumnFlags()" + ], + "attached": "// Status: is enabled == not hidden by user/api (referred to as \"Hide\" in _DefaultHide and _NoHide) flags." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2145 + } + }, + { + "name": "ImGuiTableColumnFlags_IsVisible", + "value_expression": "1<<25", + "value": 33554432, + "is_count": false, + "comments": { + "attached": "// Status: is visible == is enabled AND not clipped by scrolling." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2146 + } + }, + { + "name": "ImGuiTableColumnFlags_IsSorted", + "value_expression": "1<<26", + "value": 67108864, + "is_count": false, + "comments": { + "attached": "// Status: is currently part of the sort specs" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2147 + } + }, + { + "name": "ImGuiTableColumnFlags_IsHovered", + "value_expression": "1<<27", + "value": 134217728, + "is_count": false, + "comments": { + "attached": "// Status: is hovered by mouse" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2148 + } + }, + { + "name": "ImGuiTableColumnFlags_WidthMask_", + "value_expression": "ImGuiTableColumnFlags_WidthStretch | ImGuiTableColumnFlags_WidthFixed", + "value": 24, + "is_count": false, + "comments": { + "preceding": [ + "// [Internal] Combinations and masks" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2151 + } + }, + { + "name": "ImGuiTableColumnFlags_IndentMask_", + "value_expression": "ImGuiTableColumnFlags_IndentEnable | ImGuiTableColumnFlags_IndentDisable", + "value": 196608, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2152 + } + }, + { + "name": "ImGuiTableColumnFlags_StatusMask_", + "value_expression": "ImGuiTableColumnFlags_IsEnabled | ImGuiTableColumnFlags_IsVisible | ImGuiTableColumnFlags_IsSorted | ImGuiTableColumnFlags_IsHovered", + "value": 251658240, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2153 + } + }, + { + "name": "ImGuiTableColumnFlags_NoDirectResize_", + "value_expression": "1<<30", + "value": 1073741824, + "is_count": false, + "comments": { + "attached": "// [Internal] Disable user resizing this column directly (it may however we resized indirectly from its left edge)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2154 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::TableSetupColumn()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2120 + } + }, + { + "name": "ImGuiTableRowFlags_", + "original_fully_qualified_name": "ImGuiTableRowFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiTableRowFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2160 + } + }, + { + "name": "ImGuiTableRowFlags_Headers", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Identify header row (set default background color + width of its contents accounted differently for auto column width)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2161 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImGui::TableNextRow()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2158 + } + }, + { + "name": "ImGuiTableBgTarget_", + "original_fully_qualified_name": "ImGuiTableBgTarget_", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiTableBgTarget_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2175 + } + }, + { + "name": "ImGuiTableBgTarget_RowBg0", + "value_expression": "1", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Set row background color 0 (generally used for background, automatically set when ImGuiTableFlags_RowBg is used)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2176 + } + }, + { + "name": "ImGuiTableBgTarget_RowBg1", + "value_expression": "2", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Set row background color 1 (generally used for selection marking)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2177 + } + }, + { + "name": "ImGuiTableBgTarget_CellBg", + "value_expression": "3", + "value": 3, + "is_count": false, + "comments": { + "attached": "// Set cell background color (top-most color)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2178 + } + } + ], + "comments": { + "preceding": [ + "// Enum for ImGui::TableSetBgColor()", + "// Background colors are rendering in 3 layers:", + "// - Layer 0: draw with RowBg0 color if set, otherwise draw with ColumnBg0 if set.", + "// - Layer 1: draw with RowBg1 color if set, otherwise draw with ColumnBg1 if set.", + "// - Layer 2: draw with CellBg color if set.", + "// The purpose of the two row/columns layers is to let you decide if a background color change should override or blend with the existing color.", + "// When using ImGuiTableFlags_RowBg on the table, each row has the RowBg0 color automatically set for odd/even rows.", + "// If you set the color of RowBg0 target, your color will override the existing RowBg0 color.", + "// If you set the color of RowBg1 or ColumnBg1 target, your color will blend over the RowBg0 color." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2173 + } + }, + { + "name": "ImGuiMultiSelectFlags_", + "original_fully_qualified_name": "ImGuiMultiSelectFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiMultiSelectFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3084 + } + }, + { + "name": "ImGuiMultiSelectFlags_SingleSelect", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Disable selecting more than one item. This is available to allow single-selection code to share same code/logic if desired. It essentially disables the main purpose of BeginMultiSelect() tho!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3085 + } + }, + { + "name": "ImGuiMultiSelectFlags_NoSelectAll", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Disable CTRL+A shortcut to select all." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3086 + } + }, + { + "name": "ImGuiMultiSelectFlags_NoRangeSelect", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Disable Shift+selection mouse/keyboard support (useful for unordered 2D selection). With BoxSelect is also ensure contiguous SetRange requests are not combined into one. This allows not handling interpolation in SetRange requests." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3087 + } + }, + { + "name": "ImGuiMultiSelectFlags_NoAutoSelect", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Disable selecting items when navigating (useful for e.g. supporting range-select in a list of checkboxes)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3088 + } + }, + { + "name": "ImGuiMultiSelectFlags_NoAutoClear", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Disable clearing selection when navigating or selecting another one (generally used with ImGuiMultiSelectFlags_NoAutoSelect. useful for e.g. supporting range-select in a list of checkboxes)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3089 + } + }, + { + "name": "ImGuiMultiSelectFlags_NoAutoClearOnReselect", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Disable clearing selection when clicking/selecting an already selected item." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3090 + } + }, + { + "name": "ImGuiMultiSelectFlags_BoxSelect1d", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Enable box-selection with same width and same x pos items (e.g. full row Selectable()). Box-selection works better with little bit of spacing between items hit-box in order to be able to aim at empty space." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3091 + } + }, + { + "name": "ImGuiMultiSelectFlags_BoxSelect2d", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Enable box-selection with varying width or varying x pos items support (e.g. different width labels, or 2D layout/grid). This is slower: alters clipping logic so that e.g. horizontal movements will update selection of normally clipped items." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3092 + } + }, + { + "name": "ImGuiMultiSelectFlags_BoxSelectNoScroll", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Disable scrolling when box-selecting near edges of scope." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3093 + } + }, + { + "name": "ImGuiMultiSelectFlags_ClearOnEscape", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Clear selection when pressing Escape while scope is focused." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3094 + } + }, + { + "name": "ImGuiMultiSelectFlags_ClearOnClickVoid", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Clear selection when clicking on empty location within scope." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3095 + } + }, + { + "name": "ImGuiMultiSelectFlags_ScopeWindow", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Scope for _BoxSelect and _ClearOnClickVoid is whole window (Default). Use if BeginMultiSelect() covers a whole window or used a single time in same window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3096 + } + }, + { + "name": "ImGuiMultiSelectFlags_ScopeRect", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "attached": "// Scope for _BoxSelect and _ClearOnClickVoid is rectangle encompassing BeginMultiSelect()/EndMultiSelect(). Use if BeginMultiSelect() is called multiple times in same window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3097 + } + }, + { + "name": "ImGuiMultiSelectFlags_SelectOnClick", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Apply selection on mouse down when clicking on unselected item. (Default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3098 + } + }, + { + "name": "ImGuiMultiSelectFlags_SelectOnClickRelease", + "value_expression": "1<<14", + "value": 16384, + "is_count": false, + "comments": { + "attached": "// Apply selection on mouse release when clicking an unselected item. Allow dragging an unselected item without altering selection." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3099 + } + }, + { + "name": "ImGuiMultiSelectFlags_NavWrapX", + "value_expression": "1<<16", + "value": 65536, + "is_count": false, + "comments": { + "preceding": [ + "//ImGuiMultiSelectFlags_RangeSelect2d = 1 << 15, // Shift+Selection uses 2d geometry instead of linear sequence, so possible to use Shift+up/down to select vertically in grid. Analogous to what BoxSelect does." + ], + "attached": "// [Temporary] Enable navigation wrapping on X axis. Provided as a convenience because we don't have a design for the general Nav API for this yet. When the more general feature be public we may obsolete this flag in favor of new one." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3101 + } + } + ], + "comments": { + "preceding": [ + "// Flags for BeginMultiSelect()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3082 + } + }, + { + "name": "ImGuiSelectionRequestType", + "original_fully_qualified_name": "ImGuiSelectionRequestType", + "is_flags_enum": false, + "elements": [ + { + "name": "ImGuiSelectionRequestType_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3123 + } + }, + { + "name": "ImGuiSelectionRequestType_SetAll", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Request app to clear selection (if Selected==false) or select all items (if Selected==true). We cannot set RangeFirstItem/RangeLastItem as its contents is entirely up to user (not necessarily an index)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3124 + } + }, + { + "name": "ImGuiSelectionRequestType_SetRange", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Request app to select/unselect [RangeFirstItem..RangeLastItem] items (inclusive) based on value of Selected. Only EndMultiSelect() request this, app code can read after BeginMultiSelect() and it will always be false." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3125 + } + } + ], + "comments": { + "preceding": [ + "// Selection request type" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3121 + } + }, + { + "name": "ImDrawFlags_", + "original_fully_qualified_name": "ImDrawFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImDrawFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3299 + } + }, + { + "name": "ImDrawFlags_Closed", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// PathStroke(), AddPolyline(): specify that shape should be closed (Important: this is always == 1 for legacy reason)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3300 + } + }, + { + "name": "ImDrawFlags_RoundCornersTopLeft", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// AddRect(), AddRectFilled(), PathRect(): enable rounding top-left corner only (when rounding > 0.0f, we default to all corners). Was 0x01." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3301 + } + }, + { + "name": "ImDrawFlags_RoundCornersTopRight", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// AddRect(), AddRectFilled(), PathRect(): enable rounding top-right corner only (when rounding > 0.0f, we default to all corners). Was 0x02." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3302 + } + }, + { + "name": "ImDrawFlags_RoundCornersBottomLeft", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// AddRect(), AddRectFilled(), PathRect(): enable rounding bottom-left corner only (when rounding > 0.0f, we default to all corners). Was 0x04." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3303 + } + }, + { + "name": "ImDrawFlags_RoundCornersBottomRight", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// AddRect(), AddRectFilled(), PathRect(): enable rounding bottom-right corner only (when rounding > 0.0f, we default to all corners). Wax 0x08." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3304 + } + }, + { + "name": "ImDrawFlags_RoundCornersNone", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// AddRect(), AddRectFilled(), PathRect(): disable rounding on all corners (when rounding > 0.0f). This is NOT zero, NOT an implicit flag!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3305 + } + }, + { + "name": "ImDrawFlags_RoundCornersTop", + "value_expression": "ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersTopRight", + "value": 48, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3306 + } + }, + { + "name": "ImDrawFlags_RoundCornersBottom", + "value_expression": "ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersBottomRight", + "value": 192, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3307 + } + }, + { + "name": "ImDrawFlags_RoundCornersLeft", + "value_expression": "ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersTopLeft", + "value": 80, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3308 + } + }, + { + "name": "ImDrawFlags_RoundCornersRight", + "value_expression": "ImDrawFlags_RoundCornersBottomRight | ImDrawFlags_RoundCornersTopRight", + "value": 160, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3309 + } + }, + { + "name": "ImDrawFlags_RoundCornersAll", + "value_expression": "ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersTopRight | ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersBottomRight", + "value": 240, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3310 + } + }, + { + "name": "ImDrawFlags_RoundCornersDefault_", + "value_expression": "ImDrawFlags_RoundCornersAll", + "value": 240, + "is_count": false, + "comments": { + "attached": "// Default to ALL corners if none of the _RoundCornersXX flags are specified." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3311 + } + }, + { + "name": "ImDrawFlags_RoundCornersMask_", + "value_expression": "ImDrawFlags_RoundCornersAll | ImDrawFlags_RoundCornersNone", + "value": 496, + "is_count": false, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3312 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImDrawList functions", + "// (Legacy: bit 0 must always correspond to ImDrawFlags_Closed to be backward compatible with old API using a bool. Bits 1..3 must be unused)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3297 + } + }, + { + "name": "ImDrawListFlags_", + "original_fully_qualified_name": "ImDrawListFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImDrawListFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3319 + } + }, + { + "name": "ImDrawListFlags_AntiAliasedLines", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Enable anti-aliased lines/borders (*2 the number of triangles for 1.0f wide line or lines thin enough to be drawn using textures, otherwise *3 the number of triangles)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3320 + } + }, + { + "name": "ImDrawListFlags_AntiAliasedLinesUseTex", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Enable anti-aliased lines/borders using textures when possible. Require backend to render with bilinear filtering (NOT point/nearest filtering)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3321 + } + }, + { + "name": "ImDrawListFlags_AntiAliasedFill", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Enable anti-aliased edge around filled shapes (rounded rectangles, circles)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3322 + } + }, + { + "name": "ImDrawListFlags_AllowVtxOffset", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Can emit 'VtxOffset > 0' to allow large meshes. Set when 'ImGuiBackendFlags_RendererHasVtxOffset' is enabled." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3323 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImDrawList instance. Those are set automatically by ImGui:: functions from ImGuiIO settings, and generally not manipulated directly.", + "// It is however possible to temporarily alter flags between calls to ImDrawList:: functions." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3317 + } + }, + { + "name": "ImTextureFormat", + "original_fully_qualified_name": "ImTextureFormat", + "is_flags_enum": false, + "elements": [ + { + "name": "ImTextureFormat_RGBA32", + "value": 0, + "is_count": false, + "comments": { + "attached": "// 4 components per pixel, each is unsigned 8-bit. Total size = TexWidth * TexHeight * 4" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3528 + } + }, + { + "name": "ImTextureFormat_Alpha8", + "value": 1, + "is_count": false, + "comments": { + "attached": "// 1 component per pixel, each is unsigned 8-bit. Total size = TexWidth * TexHeight" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3529 + } + } + ], + "comments": { + "preceding": [ + "// Most standard backends only support RGBA32 but we provide a single channel option for low-resource/embedded systems." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3526 + } + }, + { + "name": "ImTextureStatus", + "original_fully_qualified_name": "ImTextureStatus", + "is_flags_enum": false, + "elements": [ + { + "name": "ImTextureStatus_OK", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3535 + } + }, + { + "name": "ImTextureStatus_Destroyed", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Backend destroyed the texture." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3536 + } + }, + { + "name": "ImTextureStatus_WantCreate", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Requesting backend to create the texture. Set status OK when done." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3537 + } + }, + { + "name": "ImTextureStatus_WantUpdates", + "value": 3, + "is_count": false, + "comments": { + "attached": "// Requesting backend to update specific blocks of pixels (write to texture portions which have never been used before). Set status OK when done." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3538 + } + }, + { + "name": "ImTextureStatus_WantDestroy", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Requesting backend to destroy the texture. Set status to Destroyed when done." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3539 + } + } + ], + "comments": { + "preceding": [ + "// Status of a texture to communicate with Renderer Backend." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3533 + } + }, + { + "name": "ImFontAtlasFlags_", + "original_fully_qualified_name": "ImFontAtlasFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImFontAtlasFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3690 + } + }, + { + "name": "ImFontAtlasFlags_NoPowerOfTwoHeight", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Don't round the height to next power of two" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3691 + } + }, + { + "name": "ImFontAtlasFlags_NoMouseCursors", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Don't build software mouse cursors into the atlas (save a little texture memory)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3692 + } + }, + { + "name": "ImFontAtlasFlags_NoBakedLines", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Don't build thick line textures into the atlas (save a little texture memory, allow support for point/nearest filtering). The AntiAliasedLinesUseTex features uses them, otherwise they will be rendered using polygons (more expensive for CPU/GPU)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3693 + } + } + ], + "comments": { + "preceding": [ + "// Flags for ImFontAtlas build" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3688 + } + }, + { + "name": "ImFontFlags_", + "original_fully_qualified_name": "ImFontFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImFontFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3901 + } + }, + { + "name": "ImFontFlags_NoLoadError", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Disable throwing an error/assert when calling AddFontXXX() with missing file/data. Calling code is expected to check AddFontXXX() return value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3902 + } + }, + { + "name": "ImFontFlags_NoLoadGlyphs", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// [Internal] Disable loading new glyphs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3903 + } + }, + { + "name": "ImFontFlags_LockBakedSizes", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// [Internal] Disable loading new baked sizes, disable garbage collecting current ones. e.g. if you want to lock a font to a single size. Important: if you use this to preload given sizes, consider the possibility of multiple font density used on Retina display." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3904 + } + } + ], + "comments": { + "preceding": [ + "// Font flags", + "// (in future versions as we redesign font loading API, this will become more important and better documented. for now please consider this as internal/advanced use)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3899 + } + }, + { + "name": "ImGuiViewportFlags_", + "original_fully_qualified_name": "ImGuiViewportFlags_", + "is_flags_enum": true, + "elements": [ + { + "name": "ImGuiViewportFlags_None", + "value_expression": "0", + "value": 0, + "is_count": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3984 + } + }, + { + "name": "ImGuiViewportFlags_IsPlatformWindow", + "value_expression": "1<<0", + "value": 1, + "is_count": false, + "comments": { + "attached": "// Represent a Platform Window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3985 + } + }, + { + "name": "ImGuiViewportFlags_IsPlatformMonitor", + "value_expression": "1<<1", + "value": 2, + "is_count": false, + "comments": { + "attached": "// Represent a Platform Monitor (unused yet)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3986 + } + }, + { + "name": "ImGuiViewportFlags_OwnedByApp", + "value_expression": "1<<2", + "value": 4, + "is_count": false, + "comments": { + "attached": "// Platform Window: Is created/managed by the user application? (rather than our backend)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3987 + } + }, + { + "name": "ImGuiViewportFlags_NoDecoration", + "value_expression": "1<<3", + "value": 8, + "is_count": false, + "comments": { + "attached": "// Platform Window: Disable platform decorations: title bar, borders, etc. (generally set all windows, but if ImGuiConfigFlags_ViewportsDecoration is set we only set this on popups/tooltips)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3988 + } + }, + { + "name": "ImGuiViewportFlags_NoTaskBarIcon", + "value_expression": "1<<4", + "value": 16, + "is_count": false, + "comments": { + "attached": "// Platform Window: Disable platform task bar icon (generally set on popups/tooltips, or all windows if ImGuiConfigFlags_ViewportsNoTaskBarIcon is set)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3989 + } + }, + { + "name": "ImGuiViewportFlags_NoFocusOnAppearing", + "value_expression": "1<<5", + "value": 32, + "is_count": false, + "comments": { + "attached": "// Platform Window: Don't take focus when created." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3990 + } + }, + { + "name": "ImGuiViewportFlags_NoFocusOnClick", + "value_expression": "1<<6", + "value": 64, + "is_count": false, + "comments": { + "attached": "// Platform Window: Don't take focus when clicked on." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3991 + } + }, + { + "name": "ImGuiViewportFlags_NoInputs", + "value_expression": "1<<7", + "value": 128, + "is_count": false, + "comments": { + "attached": "// Platform Window: Make mouse pass through so we can drag this window while peaking behind it." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3992 + } + }, + { + "name": "ImGuiViewportFlags_NoRendererClear", + "value_expression": "1<<8", + "value": 256, + "is_count": false, + "comments": { + "attached": "// Platform Window: Renderer doesn't need to clear the framebuffer ahead (because we will fill it entirely)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3993 + } + }, + { + "name": "ImGuiViewportFlags_NoAutoMerge", + "value_expression": "1<<9", + "value": 512, + "is_count": false, + "comments": { + "attached": "// Platform Window: Avoid merging this window into another host window. This can only be set via ImGuiWindowClass viewport flags override (because we need to now ahead if we are going to create a viewport in the first place!)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3994 + } + }, + { + "name": "ImGuiViewportFlags_TopMost", + "value_expression": "1<<10", + "value": 1024, + "is_count": false, + "comments": { + "attached": "// Platform Window: Display on top (for tooltips only)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3995 + } + }, + { + "name": "ImGuiViewportFlags_CanHostOtherWindows", + "value_expression": "1<<11", + "value": 2048, + "is_count": false, + "comments": { + "attached": "// Viewport can host multiple imgui windows (secondary viewports are associated to a single window). // FIXME: In practice there's still probably code making the assumption that this is always and only on the MainViewport. Will fix once we add support for \"no main viewport\"." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3996 + } + }, + { + "name": "ImGuiViewportFlags_IsMinimized", + "value_expression": "1<<12", + "value": 4096, + "is_count": false, + "comments": { + "preceding": [ + "// Output status flags (from Platform)" + ], + "attached": "// Platform Window: Window is minimized, can skip render. When minimized we tend to avoid using the viewport pos/size for clipping window or testing if they are contained in the viewport." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3999 + } + }, + { + "name": "ImGuiViewportFlags_IsFocused", + "value_expression": "1<<13", + "value": 8192, + "is_count": false, + "comments": { + "attached": "// Platform Window: Window is focused (last call to Platform_GetWindowFocus() returned true)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4000 + } + } + ], + "comments": { + "preceding": [ + "// Flags stored in ImGuiViewport::Flags, giving indications to the platform backends." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3982 + } + } + ], + "typedefs": [ + { + "name": "ImGuiID", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "preceding": [ + "// Scalar data types" + ], + "attached": "// A unique ID used by widgets (typically the result of hashing a stack of string)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImS8", + "type": { + "declaration": "signed char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "comments": { + "attached": "// 8-bit signed integer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImU8", + "type": { + "declaration": "unsigned char", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_char" + } + }, + "comments": { + "attached": "// 8-bit unsigned integer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImS16", + "type": { + "declaration": "signed short", + "description": { + "kind": "Builtin", + "builtin_type": "short" + } + }, + "comments": { + "attached": "// 16-bit signed integer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImU16", + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// 16-bit unsigned integer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImS32", + "type": { + "declaration": "signed int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// 32-bit signed integer == int" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImU32", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 32-bit unsigned integer (often used to store packed colors)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImS64", + "type": { + "declaration": "signed long long", + "description": { + "kind": "Builtin", + "builtin_type": "long_long" + } + }, + "comments": { + "attached": "// 64-bit signed integer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImU64", + "type": { + "declaration": "unsigned long long", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_long_long" + } + }, + "comments": { + "attached": "// 64-bit unsigned integer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiDir", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Enumerations", + "// - We don't use strongly typed enums much because they add constraints (can't extend in private code, can't store typed in bit fields, extra casting on iteration)", + "// - Tip: Use your programming IDE navigation facilities on the names in the _central column_ below to find the actual flags/enum lists!", + "// - In Visual Studio: CTRL+comma (\"Edit.GoToAll\") can follow symbols inside comments, whereas CTRL+F12 (\"Edit.GoToImplementation\") cannot.", + "// - In Visual Studio w/ Visual Assist installed: ALT+G (\"VAssistX.GoToImplementation\") can also follow symbols inside comments.", + "// - In VS Code, CLion, etc.: CTRL+click can follow symbols inside comments." + ], + "attached": "// -> enum ImGuiDir // Enum: A cardinal direction (Left, Right, Up, Down)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiKey", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiKey // Enum: A key identifier (ImGuiKey_XXX or ImGuiMod_XXX value)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiMouseSource", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiMouseSource // Enum; A mouse input source identifier (Mouse, TouchScreen, Pen)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiSortDirection", + "type": { + "declaration": "ImU8", + "description": { + "kind": "User", + "name": "ImU8" + } + }, + "comments": { + "attached": "// -> enum ImGuiSortDirection // Enum: A sorting direction (ascending or descending)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiCol", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiCol_ // Enum: A color identifier for styling" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiCond", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiCond_ // Enum: A condition for many Set*() functions" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiDataType", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiDataType_ // Enum: A primary data type" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiMouseButton", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiMouseButton_ // Enum: A mouse button identifier (0=left, 1=right, 2=middle)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiMouseCursor", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiMouseCursor_ // Enum: A mouse cursor shape" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiStyleVar", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiStyleVar_ // Enum: A variable identifier for styling" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiTableBgTarget", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTableBgTarget_ // Enum: A color target for TableSetBgColor()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImDrawFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Flags (declared as int to allow using as flags without overhead, and to not pollute the top of this file)", + "// - Tip: Use your programming IDE navigation facilities on the names in the _central column_ below to find the actual flags/enum lists!", + "// - In Visual Studio: CTRL+comma (\"Edit.GoToAll\") can follow symbols inside comments, whereas CTRL+F12 (\"Edit.GoToImplementation\") cannot.", + "// - In Visual Studio w/ Visual Assist installed: ALT+G (\"VAssistX.GoToImplementation\") can also follow symbols inside comments.", + "// - In VS Code, CLion, etc.: CTRL+click can follow symbols inside comments." + ], + "attached": "// -> enum ImDrawFlags_ // Flags: for ImDrawList functions" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImDrawListFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImDrawListFlags_ // Flags: for ImDrawList instance" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImFontFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImFontFlags_ // Flags: for ImFont" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImFontAtlasFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImFontAtlasFlags_ // Flags: for ImFontAtlas" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiBackendFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiBackendFlags_ // Flags: for io.BackendFlags" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiButtonFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiButtonFlags_ // Flags: for InvisibleButton()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiChildFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiChildFlags_ // Flags: for BeginChild()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiColorEditFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiColorEditFlags_ // Flags: for ColorEdit4(), ColorPicker4() etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiConfigFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiConfigFlags_ // Flags: for io.ConfigFlags" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiComboFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiComboFlags_ // Flags: for BeginCombo()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiDockNodeFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiDockNodeFlags_ // Flags: for DockSpace()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiDragDropFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiDragDropFlags_ // Flags: for BeginDragDropSource(), AcceptDragDropPayload()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiFocusedFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiFocusedFlags_ // Flags: for IsWindowFocused()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiHoveredFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiHoveredFlags_ // Flags: for IsItemHovered(), IsWindowHovered() etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiInputFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiInputFlags_ // Flags: for Shortcut(), SetNextItemShortcut()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiInputTextFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiInputTextFlags_ // Flags: for InputText(), InputTextMultiline()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiItemFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiItemFlags_ // Flags: for PushItemFlag(), shared by all items" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiKeyChord", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> ImGuiKey | ImGuiMod_XXX // Flags: for IsKeyChordPressed(), Shortcut() etc. an ImGuiKey optionally OR-ed with one or more ImGuiMod_XXX values." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiPopupFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiPopupFlags_ // Flags: for OpenPopup*(), BeginPopupContext*(), IsPopupOpen()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiMultiSelectFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiMultiSelectFlags_// Flags: for BeginMultiSelect()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiSelectableFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiSelectableFlags_ // Flags: for Selectable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiSliderFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiSliderFlags_ // Flags: for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiTabBarFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTabBarFlags_ // Flags: for BeginTabBar()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiTabItemFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTabItemFlags_ // Flags: for BeginTabItem()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiTableFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTableFlags_ // Flags: For BeginTable()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiTableColumnFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTableColumnFlags_// Flags: For TableSetupColumn()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiTableRowFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTableRowFlags_ // Flags: For TableNextRow()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiTreeNodeFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiTreeNodeFlags_ // Flags: for TreeNode(), TreeNodeEx(), CollapsingHeader()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiViewportFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiViewportFlags_ // Flags: for ImGuiViewport" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiWindowFlags", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// -> enum ImGuiWindowFlags_ // Flags: for Begin(), BeginChild()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImWchar32", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "preceding": [ + "// Character types", + "// (we generally use UTF-8 encoded string in the API. This is storage specifically for a decoded character used for keyboard input and display)" + ], + "attached": "// A single decoded U32 character/code point. We encode them as multi bytes UTF-8 when used in strings." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImWchar16", + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// A single decoded U16 character/code point. We encode them as multi bytes UTF-8 when used in strings." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImWchar", + "type": { + "declaration": "ImWchar32", + "description": { + "kind": "User", + "name": "ImWchar32" + } + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_USE_WCHAR32" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImWchar", + "type": { + "declaration": "ImWchar16", + "description": { + "kind": "User", + "name": "ImWchar16" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_USE_WCHAR32" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiSelectionUserData", + "type": { + "declaration": "ImS64", + "description": { + "kind": "User", + "name": "ImS64" + } + }, + "comments": { + "preceding": [ + "// Multi-Selection item index or identifier when using BeginMultiSelect()", + "// - Used by SetNextItemSelectionUserData() + and inside ImGuiMultiSelectIO structure.", + "// - Most users are likely to use this store an item INDEX but this may be used to store a POINTER/ID as well. Read comments near ImGuiMultiSelectIO for details." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiInputTextCallback", + "type": { + "declaration": "int (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData* data)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "ImGuiInputTextCallbackData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextCallbackData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ImGuiInputTextCallback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "int" + }, + "parameters": [ + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextCallbackData" + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Callback and functions types" + ], + "attached": "// Callback function for ImGui::InputText()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiSizeCallback", + "type": { + "declaration": "void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "ImGuiSizeCallbackData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSizeCallbackData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ImGuiSizeCallback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSizeCallbackData" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Callback function for ImGui::SetNextWindowSizeConstraints()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiMemAllocFunc", + "type": { + "declaration": "void* (*ImGuiMemAllocFunc)(size_t sz, void* user_data)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "sz", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ImGuiMemAllocFunc", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "parameters": [ + { + "kind": "Type", + "name": "sz", + "inner_type": { + "kind": "User", + "name": "size_t" + } + }, + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Function signature for ImGui::SetAllocatorFunctions()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImGuiMemFreeFunc", + "type": { + "declaration": "void (*ImGuiMemFreeFunc)(void* ptr, void* user_data)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ptr", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ImGuiMemFreeFunc", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ptr", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// Function signature for ImGui::SetAllocatorFunctions()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImTextureID", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "comments": { + "attached": "// Default: store up to 64-bits (any pointer or integer). A majority of backends are ok with that." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "ImTextureID" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImDrawIdx", + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Default: 16-bit (for maximum compatibility with renderer backends)" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "ImDrawIdx" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImDrawCallback", + "type": { + "declaration": "void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "parent_list", + "type": { + "declaration": "const ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cmd", + "type": { + "declaration": "const ImDrawCmd*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawCmd", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "ImDrawCallback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "parent_list", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + { + "kind": "Type", + "name": "cmd", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawCmd", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "ImDrawCallback" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImFontAtlasRectId", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// An opaque identifier to a rectangle in the atlas. -1 when invalid.", + "// The rectangle may move and UV may be invalidated, use GetCustomRect() to retrieve it." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ImFontAtlasCustomRect", + "type": { + "declaration": "ImFontAtlasRect", + "description": { + "kind": "User", + "name": "ImFontAtlasRect" + } + }, + "comments": { + "preceding": [ + "//-- OBSOLETED in 1.92.x: ImFontAtlasCustomRect becomes ImTextureRect", + "// - ImFontAtlasCustomRect::X,Y --> ImTextureRect::x,y", + "// - ImFontAtlasCustomRect::Width,Height --> ImTextureRect::w,h", + "// - ImFontAtlasCustomRect::GlyphColored --> if you need to write to this, instead you can write to 'font->Glyphs.back()->Colored' after calling AddCustomRectFontGlyph()", + "// We could make ImTextureRect an union to use old names, but 1) this would be confusing 2) the fix is easy 3) ImFontAtlasCustomRect was always a rather esoteric api." + ] + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + } + ], + "structs": [ + { + "name": "ImDrawListSharedData", + "original_fully_qualified_name": "ImDrawListSharedData", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "attached": "// Data shared among multiple draw lists (typically owned by parent ImGui context, but you may create one yourself)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 171 + } + }, + { + "name": "ImFontAtlasBuilder", + "original_fully_qualified_name": "ImFontAtlasBuilder", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "attached": "// Opaque storage for building a ImFontAtlas" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 176 + } + }, + { + "name": "ImFontLoader", + "original_fully_qualified_name": "ImFontLoader", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "attached": "// Opaque interface to a font loading backend (stb_truetype, FreeType etc.)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 182 + } + }, + { + "name": "ImGuiContext", + "original_fully_qualified_name": "ImGuiContext", + "kind": "struct", + "by_value": false, + "forward_declaration": true, + "is_anonymous": false, + "fields": [], + "comments": { + "preceding": [ + "// Forward declarations: ImGui layer" + ], + "attached": "// Dear ImGui context (opaque structure, unless including imgui_internal.h)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 188 + } + }, + { + "name": "ImVec2", + "original_fully_qualified_name": "ImVec2", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "x", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 294 + } + }, + { + "name": "y", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 294 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 292 + } + }, + { + "name": "ImVec4", + "original_fully_qualified_name": "ImVec4", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "x", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 307 + } + }, + { + "name": "y", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 307 + } + }, + { + "name": "z", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 307 + } + }, + { + "name": "w", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 307 + } + } + ], + "comments": { + "preceding": [ + "// ImVec4: 4D vector used to store clipping rectangles, colors etc. [Compile-time configurable type]" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 305 + } + }, + { + "name": "ImTextureRef", + "original_fully_qualified_name": "ImTextureRef", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "_TexData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "comments": { + "preceding": [ + "// Members (either are set, never both!)" + ], + "attached": "// A texture, generally owned by a ImFontAtlas. Will convert to ImTextureID during render loop, after texture has been uploaded." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 373 + } + }, + { + "name": "_TexID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureID", + "description": { + "kind": "User", + "name": "ImTextureID" + } + }, + "comments": { + "attached": "// _OR_ Low-level backend texture identifier, if already uploaded or created by user/app. Generally provided to e.g. ImGui::Image() calls." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 374 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 362 + } + }, + { + "name": "ImGuiTableSortSpecs", + "original_fully_qualified_name": "ImGuiTableSortSpecs", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Specs", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const ImGuiTableColumnSortSpecs*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableColumnSortSpecs", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Pointer to sort spec array." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2187 + } + }, + { + "name": "SpecsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Sort spec count. Most often 1. May be > 1 when ImGuiTableFlags_SortMulti is enabled. May be == 0 when ImGuiTableFlags_SortTristate is enabled." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2188 + } + }, + { + "name": "SpecsDirty", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to true when specs have changed since last time! Use this to sort again, then clear the flag." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2189 + } + } + ], + "comments": { + "preceding": [ + "// Sorting specifications for a table (often handling sort specs for a single column, occasionally more)", + "// Obtained by calling TableGetSortSpecs().", + "// When 'SpecsDirty == true' you can sort your data. It will be true with sorting specs have changed since last call, or the first time.", + "// Make sure to set 'SpecsDirty = false' after sorting, else you may wastefully sort your data every frame!" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2185 + } + }, + { + "name": "ImGuiTableColumnSortSpecs", + "original_fully_qualified_name": "ImGuiTableColumnSortSpecs", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ColumnUserID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// User id of the column (if specified by a TableSetupColumn() call)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2197 + } + }, + { + "name": "ColumnIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Index of the column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2198 + } + }, + { + "name": "SortOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS16", + "description": { + "kind": "User", + "name": "ImS16" + } + }, + "comments": { + "attached": "// Index within parent ImGuiTableSortSpecs (always stored in order starting from 0, tables sorted on a single criteria will always have a 0 here)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2199 + } + }, + { + "name": "SortDirection", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSortDirection", + "description": { + "kind": "User", + "name": "ImGuiSortDirection" + } + }, + "comments": { + "attached": "// ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2200 + } + } + ], + "comments": { + "preceding": [ + "// Sorting specification for one column of a table (sizeof == 12 bytes)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2195 + } + }, + { + "name": "ImVector_ImGuiTextRange", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTextFilter_ImGuiTextRange*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter_ImGuiTextRange" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiStoragePair", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStoragePair*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStoragePair" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiSelectionRequest", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionRequest*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionRequest" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImDrawCmd", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawCmd*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawCmd" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImDrawIdx", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawIdx*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawIdx" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImDrawVert", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawVert*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawVert" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImVec4", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec4" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImTextureRef", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRef*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureRef" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImU8", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU8*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU8" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImWchar", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImFontPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImFontConfig", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImDrawListSharedDataPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListSharedData**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawListSharedData" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImU16", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU16*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU16" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImFontGlyph", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImFontConfigPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontConfig**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiPlatformMonitor", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiPlatformMonitor*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPlatformMonitor" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImGuiViewportPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewport**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImU32", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU32" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImVec2", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImDrawChannel", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawChannel*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawChannel" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImTextureDataPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureData**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_char", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_float", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImDrawListPtr", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawList**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImVector_ImTextureRect", + "original_fully_qualified_name": "ImVector", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2249 + } + }, + { + "name": "Capacity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2250 + } + }, + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureRect" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2251 + } + } + ], + "comments": { + "attached": "// Instantiation of ImVector" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2247 + } + }, + { + "name": "ImGuiStyle", + "original_fully_qualified_name": "ImGuiStyle", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "FontSizeBase", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// Font scaling", + "// - recap: ImGui::GetFontSize() == FontSizeBase * (FontScaleMain * FontScaleDpi * other_scaling_factors)" + ], + "attached": "// Current base font size before external global factors are applied. Use PushFont(NULL, size) to modify. Use ImGui::GetFontSize() to obtain scaled value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2323 + } + }, + { + "name": "FontScaleMain", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Main global scale factor. May be set by application once, or exposed to end-user." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2324 + } + }, + { + "name": "FontScaleDpi", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Additional global scale factor from viewport/monitor contents scale. When io.ConfigDpiScaleFonts is enabled, this is automatically overwritten when changing monitor DPI." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2325 + } + }, + { + "name": "Alpha", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Global alpha applies to everything in Dear ImGui." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2327 + } + }, + { + "name": "DisabledAlpha", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Additional alpha multiplier applied by BeginDisabled(). Multiply over current value of Alpha." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2328 + } + }, + { + "name": "WindowPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Padding within a window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2329 + } + }, + { + "name": "WindowRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of window corners rounding. Set to 0.0f to have rectangular windows. Large values tend to lead to variety of artifacts and are not recommended." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2330 + } + }, + { + "name": "WindowBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of border around windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2331 + } + }, + { + "name": "WindowBorderHoverPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Hit-testing extent outside/inside resizing border. Also extend determination of hovered window. Generally meaningfully larger than WindowBorderSize to make it easy to reach borders." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2332 + } + }, + { + "name": "WindowMinSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Minimum window size. This is a global setting. If you want to constrain individual windows, use SetNextWindowSizeConstraints()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2333 + } + }, + { + "name": "WindowTitleAlign", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2334 + } + }, + { + "name": "WindowMenuButtonPosition", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "comments": { + "attached": "// Side of the collapsing/docking button in the title bar (None/Left/Right). Defaults to ImGuiDir_Left." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2335 + } + }, + { + "name": "ChildRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of child window corners rounding. Set to 0.0f to have rectangular windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2336 + } + }, + { + "name": "ChildBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of border around child windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2337 + } + }, + { + "name": "PopupRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of popup window corners rounding. (Note that tooltip windows use WindowRounding)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2338 + } + }, + { + "name": "PopupBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of border around popup/tooltip windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2339 + } + }, + { + "name": "FramePadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Padding within a framed rectangle (used by most widgets)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2340 + } + }, + { + "name": "FrameRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2341 + } + }, + { + "name": "FrameBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of border around frames. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2342 + } + }, + { + "name": "ItemSpacing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Horizontal and vertical spacing between widgets/lines." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2343 + } + }, + { + "name": "ItemInnerSpacing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2344 + } + }, + { + "name": "CellPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Padding within a table cell. Cellpadding.x is locked for entire table. CellPadding.y may be altered between different rows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2345 + } + }, + { + "name": "TouchExtraPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2346 + } + }, + { + "name": "IndentSpacing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2347 + } + }, + { + "name": "ColumnsMinSpacing", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Minimum horizontal spacing between two columns. Preferably > (FramePadding.x + 1)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2348 + } + }, + { + "name": "ScrollbarSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Width of the vertical scrollbar, Height of the horizontal scrollbar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2349 + } + }, + { + "name": "ScrollbarRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of grab corners for scrollbar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2350 + } + }, + { + "name": "GrabMinSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Minimum width/height of a grab box for slider/scrollbar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2351 + } + }, + { + "name": "GrabRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2352 + } + }, + { + "name": "LogSliderDeadzone", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// The size in pixels of the dead-zone around zero on logarithmic sliders that cross zero." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2353 + } + }, + { + "name": "ImageBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of border around Image() calls." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2354 + } + }, + { + "name": "TabRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of upper corners of a tab. Set to 0.0f to have rectangular tabs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2355 + } + }, + { + "name": "TabBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of border around tabs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2356 + } + }, + { + "name": "TabMinWidthBase", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Minimum tab width, to make tabs larger than their contents. TabBar buttons are not affected." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2357 + } + }, + { + "name": "TabMinWidthShrink", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Minimum tab width after shrinking, when using ImGuiTabBarFlags_FittingPolicyMixed policy." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2358 + } + }, + { + "name": "TabCloseButtonMinWidthSelected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// -1: always visible. 0.0f: visible when hovered. >0.0f: visible when hovered if minimum width." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2359 + } + }, + { + "name": "TabCloseButtonMinWidthUnselected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// -1: always visible. 0.0f: visible when hovered. >0.0f: visible when hovered if minimum width. FLT_MAX: never show close button when unselected." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2360 + } + }, + { + "name": "TabBarBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of tab-bar separator, which takes on the tab active color to denote focus." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2361 + } + }, + { + "name": "TabBarOverlineSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of tab-bar overline, which highlights the selected tab-bar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2362 + } + }, + { + "name": "TableAngledHeadersAngle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Angle of angled headers (supported values range from -50.0f degrees to +50.0f degrees)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2363 + } + }, + { + "name": "TableAngledHeadersTextAlign", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Alignment of angled headers within the cell" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2364 + } + }, + { + "name": "TreeLinesFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "comments": { + "attached": "// Default way to draw lines connecting TreeNode hierarchy. ImGuiTreeNodeFlags_DrawLinesNone or ImGuiTreeNodeFlags_DrawLinesFull or ImGuiTreeNodeFlags_DrawLinesToNodes." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2365 + } + }, + { + "name": "TreeLinesSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of outlines when using ImGuiTreeNodeFlags_DrawLines." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2366 + } + }, + { + "name": "TreeLinesRounding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Radius of lines connecting child nodes to the vertical line." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2367 + } + }, + { + "name": "ColorButtonPosition", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "comments": { + "attached": "// Side of the color button in the ColorEdit4 widget (left/right). Defaults to ImGuiDir_Right." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2368 + } + }, + { + "name": "ButtonTextAlign", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2369 + } + }, + { + "name": "SelectableTextAlign", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned). It's generally important to keep this left-aligned if you want to lay multiple items on a same line." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2370 + } + }, + { + "name": "SeparatorTextBorderSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of border in SeparatorText()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2371 + } + }, + { + "name": "SeparatorTextAlign", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Alignment of text within the separator. Defaults to (0.0f, 0.5f) (left aligned, center)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2372 + } + }, + { + "name": "SeparatorTextPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Horizontal offset of text from each edge of the separator + spacing on other axis. Generally small values. .y is recommended to be == FramePadding.y." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2373 + } + }, + { + "name": "DisplayWindowPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Apply to regular windows: amount which we enforce to keep visible when moving near edges of your screen." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2374 + } + }, + { + "name": "DisplaySafeAreaPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Apply to every windows, menus, popups, tooltips: amount where we avoid displaying contents. Adjust if you cannot see the edges of your screen (e.g. on a TV where scaling has not been configured)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2375 + } + }, + { + "name": "DockingSeparatorSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Thickness of resizing border between docked windows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2376 + } + }, + { + "name": "MouseCursorScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Scale software rendered mouse cursor (when io.MouseDrawCursor is enabled). We apply per-monitor DPI scaling over this scale. May be removed later." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2377 + } + }, + { + "name": "AntiAliasedLines", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2378 + } + }, + { + "name": "AntiAliasedLinesUseTex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Enable anti-aliased lines/borders using textures where possible. Require backend to render with bilinear filtering (NOT point/nearest filtering). Latched at the beginning of the frame (copied to ImDrawList)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2379 + } + }, + { + "name": "AntiAliasedFill", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.). Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2380 + } + }, + { + "name": "CurveTessellationTol", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Tessellation tolerance when using PathBezierCurveTo() without a specific number of segments. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2381 + } + }, + { + "name": "CircleTessellationMaxError", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Maximum error (in pixels) allowed when using AddCircle()/AddCircleFilled() or drawing rounded corner rectangles with no explicit segment count specified. Decrease for higher quality but more geometry." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2382 + } + }, + { + "name": "Colors", + "is_array": true, + "array_bounds": "ImGuiCol_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImVec4[ImGuiCol_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiCol_COUNT", + "inner_type": { + "kind": "User", + "name": "ImVec4" + } + } + }, + "comments": { + "preceding": [ + "// Colors" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2385 + } + }, + { + "name": "HoverStationaryDelay", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// Behaviors", + "// (It is possible to modify those fields mid-frame if specific behavior need it, unlike e.g. configuration fields in ImGuiIO)" + ], + "attached": "// Delay for IsItemHovered(ImGuiHoveredFlags_Stationary). Time required to consider mouse stationary." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2389 + } + }, + { + "name": "HoverDelayShort", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Delay for IsItemHovered(ImGuiHoveredFlags_DelayShort). Usually used along with HoverStationaryDelay." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2390 + } + }, + { + "name": "HoverDelayNormal", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Delay for IsItemHovered(ImGuiHoveredFlags_DelayNormal). \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2391 + } + }, + { + "name": "HoverFlagsForTooltipMouse", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiHoveredFlags", + "description": { + "kind": "User", + "name": "ImGuiHoveredFlags" + } + }, + "comments": { + "attached": "// Default flags when using IsItemHovered(ImGuiHoveredFlags_ForTooltip) or BeginItemTooltip()/SetItemTooltip() while using mouse." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2392 + } + }, + { + "name": "HoverFlagsForTooltipNav", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiHoveredFlags", + "description": { + "kind": "User", + "name": "ImGuiHoveredFlags" + } + }, + "comments": { + "attached": "// Default flags when using IsItemHovered(ImGuiHoveredFlags_ForTooltip) or BeginItemTooltip()/SetItemTooltip() while using keyboard/gamepad." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2393 + } + }, + { + "name": "_MainScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// [Internal]" + ], + "attached": "// FIXME-WIP: Reference scale, as applied by ScaleAllSizes()." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2396 + } + }, + { + "name": "_NextFrameFontSizeBase", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// FIXME: Temporary hack until we finish remaining work." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2397 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2319 + } + }, + { + "name": "ImGuiKeyData", + "original_fully_qualified_name": "ImGuiKeyData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Down", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// True for if key is down" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2425 + } + }, + { + "name": "DownDuration", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Duration the key has been down (<0.0f: not pressed, 0.0f: just pressed, >0.0f: time held)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2426 + } + }, + { + "name": "DownDurationPrev", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Last frame duration the key has been down" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2427 + } + }, + { + "name": "AnalogValue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 0.0f..1.0f for gamepad values" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2428 + } + } + ], + "comments": { + "preceding": [ + "// [Internal] Storage used by IsKeyDown(), IsKeyPressed() etc functions.", + "// If prior to 1.87 you used io.KeysDownDuration[] (which was marked as internal), you should use GetKeyData(key)->DownDuration and *NOT* io.KeysData[key]->DownDuration." + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2423 + } + }, + { + "name": "ImGuiIO", + "original_fully_qualified_name": "ImGuiIO", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ConfigFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiConfigFlags", + "description": { + "kind": "User", + "name": "ImGuiConfigFlags" + } + }, + "comments": { + "attached": "// = 0 // See ImGuiConfigFlags_ enum. Set by user/application. Keyboard/Gamepad navigation options, etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2437 + } + }, + { + "name": "BackendFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiBackendFlags", + "description": { + "kind": "User", + "name": "ImGuiBackendFlags" + } + }, + "comments": { + "attached": "// = 0 // See ImGuiBackendFlags_ enum. Set by backend (imgui_impl_xxx files or custom backend) to communicate features supported by the backend." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2438 + } + }, + { + "name": "DisplaySize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// // Main display size, in pixels (== GetMainViewport()->Size). May change every frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2439 + } + }, + { + "name": "DisplayFramebufferScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// = (1, 1) // Main display density. For retina display where window coordinates are different from framebuffer coordinates. This will affect font density + will end up in ImDrawData::FramebufferScale." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2440 + } + }, + { + "name": "DeltaTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// = 1.0f/60.0f // Time elapsed since last frame, in seconds. May change every frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2441 + } + }, + { + "name": "IniSavingRate", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// = 5.0f // Minimum time between saving positions/sizes to .ini file, in seconds." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2442 + } + }, + { + "name": "IniFilename", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// = \"imgui.ini\" // Path to .ini file (important: default \"imgui.ini\" is relative to current working dir!). Set NULL to disable automatic .ini loading/saving or if you want to manually call LoadIniSettingsXXX() / SaveIniSettingsXXX() functions." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2443 + } + }, + { + "name": "LogFilename", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// = \"imgui_log.txt\"// Path to .log file (default parameter to ImGui::LogToFile when no file is specified)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2444 + } + }, + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// = NULL // Store your own data." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2445 + } + }, + { + "name": "Fonts", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "comments": { + "preceding": [ + "// Font system" + ], + "attached": "// // Font atlas: load, rasterize and pack one or more fonts into a single texture." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2448 + } + }, + { + "name": "FontDefault", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "comments": { + "attached": "// = NULL // Font to use on NewFrame(). Use NULL to uses Fonts->Fonts[0]." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2449 + } + }, + { + "name": "FontAllowUserScaling", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // [OBSOLETE] Allow user scaling text of individual window with CTRL+Wheel." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2450 + } + }, + { + "name": "ConfigNavSwapGamepadButtons", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Keyboard/Gamepad Navigation options" + ], + "attached": "// = false // Swap Activate<>Cancel (A<>B) buttons, matching typical \"Nintendo/Japanese style\" gamepad layout." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2453 + } + }, + { + "name": "ConfigNavMoveSetMousePos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Directional/tabbing navigation teleports the mouse cursor. May be useful on TV/console systems where moving a virtual mouse is difficult. Will update io.MousePos and set io.WantSetMousePos=true." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2454 + } + }, + { + "name": "ConfigNavCaptureKeyboard", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Sets io.WantCaptureKeyboard when io.NavActive is set." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2455 + } + }, + { + "name": "ConfigNavEscapeClearFocusItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Pressing Escape can clear focused item + navigation id/highlight. Set to false if you want to always keep highlight on." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2456 + } + }, + { + "name": "ConfigNavEscapeClearFocusWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Pressing Escape can clear focused window as well (super set of io.ConfigNavEscapeClearFocusItem)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2457 + } + }, + { + "name": "ConfigNavCursorVisibleAuto", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Using directional navigation key makes the cursor visible. Mouse click hides the cursor." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2458 + } + }, + { + "name": "ConfigNavCursorVisibleAlways", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Navigation cursor is always visible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2459 + } + }, + { + "name": "ConfigDockingNoSplit", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Docking options (when ImGuiConfigFlags_DockingEnable is set)" + ], + "attached": "// = false // Simplified docking mode: disable window splitting, so docking is limited to merging multiple windows together into tab-bars." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2462 + } + }, + { + "name": "ConfigDockingWithShift", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Enable docking with holding Shift key (reduce visual noise, allows dropping in wider space)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2463 + } + }, + { + "name": "ConfigDockingAlwaysTabBar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // [BETA] [FIXME: This currently creates regression with auto-sizing and general overhead] Make every single floating window display within a docking node." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2464 + } + }, + { + "name": "ConfigDockingTransparentPayload", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // [BETA] Make window or viewport transparent when docking and only display docking boxes on the target viewport. Useful if rendering of multiple viewport cannot be synced. Best used with ConfigViewportsNoAutoMerge." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2465 + } + }, + { + "name": "ConfigViewportsNoAutoMerge", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Viewport options (when ImGuiConfigFlags_ViewportsEnable is set)" + ], + "attached": "// = false; // Set to make all floating imgui windows always create their own viewport. Otherwise, they are merged into the main host viewports when overlapping it. May also set ImGuiViewportFlags_NoAutoMerge on individual viewport." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2468 + } + }, + { + "name": "ConfigViewportsNoTaskBarIcon", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Disable default OS task bar icon flag for secondary viewports. When a viewport doesn't want a task bar icon, ImGuiViewportFlags_NoTaskBarIcon will be set on it." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2469 + } + }, + { + "name": "ConfigViewportsNoDecoration", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Disable default OS window decoration flag for secondary viewports. When a viewport doesn't want window decorations, ImGuiViewportFlags_NoDecoration will be set on it. Enabling decoration can create subsequent issues at OS levels (e.g. minimum window size)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2470 + } + }, + { + "name": "ConfigViewportsNoDefaultParent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Disable default OS parenting to main viewport for secondary viewports. By default, viewports are marked with ParentViewportId = , expecting the platform backend to setup a parent/child relationship between the OS windows (some backend may ignore this). Set to true if you want the default to be 0, then all viewports will be top-level OS windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2471 + } + }, + { + "name": "ConfigViewportPlatformFocusSetsImGuiFocus", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "//= true // When a platform window is focused (e.g. using Alt+Tab, clicking Platform Title Bar), apply corresponding focus on imgui windows (may clear focus/active id from imgui windows location in other platform windows). In principle this is better enabled but we provide an opt-out, because some Linux window managers tend to eagerly focus windows (e.g. on mouse hover, or even a simple window pos/size change)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2472 + } + }, + { + "name": "ConfigDpiScaleFonts", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// DPI/Scaling options", + "// This may keep evolving during 1.92.x releases. Expect some turbulence." + ], + "attached": "// = false // [EXPERIMENTAL] Automatically overwrite style.FontScaleDpi when Monitor DPI changes. This will scale fonts but _NOT_ scale sizes/padding for now." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2476 + } + }, + { + "name": "ConfigDpiScaleViewports", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // [EXPERIMENTAL] Scale Dear ImGui and Platform Windows when Monitor DPI changes." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2477 + } + }, + { + "name": "MouseDrawCursor", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Miscellaneous options", + "// (you can visualize and interact with all options in 'Demo->Configuration')" + ], + "attached": "// = false // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor). Cannot be easily renamed to 'io.ConfigXXX' because this is frequently used by backend implementations." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2481 + } + }, + { + "name": "ConfigMacOSXBehaviors", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = defined(__APPLE__) // Swap Cmd<>Ctrl keys + OS X style text editing cursor movement using Alt instead of Ctrl, Shortcuts using Cmd/Super instead of Ctrl, Line/Text Start and End using Cmd+Arrows instead of Home/End, Double click selects by word instead of selecting whole text, Multi-selection in lists uses Cmd/Super instead of Ctrl." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2482 + } + }, + { + "name": "ConfigInputTrickleEventQueue", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Enable input queue trickling: some types of events submitted during the same frame (e.g. button down + up) will be spread over multiple frames, improving interactions with low framerates." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2483 + } + }, + { + "name": "ConfigInputTextCursorBlink", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Enable blinking cursor (optional as some users consider it to be distracting)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2484 + } + }, + { + "name": "ConfigInputTextEnterKeepActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // [BETA] Pressing Enter will keep item active and select contents (single-line only)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2485 + } + }, + { + "name": "ConfigDragClickToInputText", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // [BETA] Enable turning DragXXX widgets into text input with a simple mouse click-release (without moving). Not desirable on devices without a keyboard." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2486 + } + }, + { + "name": "ConfigWindowsResizeFromEdges", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Enable resizing of windows from their edges and from the lower-left corner. This requires ImGuiBackendFlags_HasMouseCursors for better mouse cursor feedback. (This used to be a per-window ImGuiWindowFlags_ResizeFromAnySide flag)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2487 + } + }, + { + "name": "ConfigWindowsMoveFromTitleBarOnly", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Enable allowing to move windows only when clicking on their title bar. Does not apply to windows without a title bar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2488 + } + }, + { + "name": "ConfigWindowsCopyContentsWithCtrlC", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // [EXPERIMENTAL] CTRL+C copy the contents of focused window into the clipboard. Experimental because: (1) has known issues with nested Begin/End pairs (2) text output quality varies (3) text output is in submission order rather than spatial order." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2489 + } + }, + { + "name": "ConfigScrollbarScrollByPage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Enable scrolling page by page when clicking outside the scrollbar grab. When disabled, always scroll to clicked location. When enabled, Shift+Click scrolls to clicked location." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2490 + } + }, + { + "name": "ConfigMemoryCompactTimer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// = 60.0f // Timer (in seconds) to free transient windows/tables memory buffers when unused. Set to -1.0f to disable." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2491 + } + }, + { + "name": "MouseDoubleClickTime", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// Inputs Behaviors", + "// (other variables, ones which are expected to be tweaked within UI code, are exposed in ImGuiStyle)" + ], + "attached": "// = 0.30f // Time for a double-click, in seconds." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2495 + } + }, + { + "name": "MouseDoubleClickMaxDist", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// = 6.0f // Distance threshold to stay in to validate a double-click, in pixels." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2496 + } + }, + { + "name": "MouseDragThreshold", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// = 6.0f // Distance threshold before considering we are dragging." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2497 + } + }, + { + "name": "KeyRepeatDelay", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// = 0.275f // When holding a key/button, time before it starts repeating, in seconds (for buttons in Repeat mode, etc.)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2498 + } + }, + { + "name": "KeyRepeatRate", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// = 0.050f // When holding a key/button, rate at which it repeats, in seconds." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2499 + } + }, + { + "name": "ConfigErrorRecovery", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Options to configure Error Handling and how we handle recoverable errors [EXPERIMENTAL]", + "// - Error recovery is provided as a way to facilitate:", + "// - Recovery after a programming error (native code or scripting language - the later tends to facilitate iterating on code while running).", + "// - Recovery after running an exception handler or any error processing which may skip code after an error has been detected.", + "// - Error recovery is not perfect nor guaranteed! It is a feature to ease development.", + "// You not are not supposed to rely on it in the course of a normal application run.", + "// - Functions that support error recovery are using IM_ASSERT_USER_ERROR() instead of IM_ASSERT().", + "// - By design, we do NOT allow error recovery to be 100% silent. One of the three options needs to be checked!", + "// - Always ensure that on programmers seats you have at minimum Asserts or Tooltips enabled when making direct imgui API calls!", + "// Otherwise it would severely hinder your ability to catch and correct mistakes!", + "// Read https://github.com/ocornut/imgui/wiki/Error-Handling for details.", + "// - Programmer seats: keep asserts (default), or disable asserts and keep error tooltips (new and nice!)", + "// - Non-programmer seats: maybe disable asserts, but make sure errors are resurfaced (tooltips, visible log entries, use callback etc.)", + "// - Recovery after error/exception: record stack sizes with ErrorRecoveryStoreState(), disable assert, set log callback (to e.g. trigger high-level breakpoint), recover with ErrorRecoveryTryToRecoverState(), restore settings." + ], + "attached": "// = true // Enable error recovery support. Some errors won't be detected and lead to direct crashes if recovery is disabled." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2519 + } + }, + { + "name": "ConfigErrorRecoveryEnableAssert", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Enable asserts on recoverable error. By default call IM_ASSERT() when returning from a failing IM_ASSERT_USER_ERROR()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2520 + } + }, + { + "name": "ConfigErrorRecoveryEnableDebugLog", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Enable debug log output on recoverable errors." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2521 + } + }, + { + "name": "ConfigErrorRecoveryEnableTooltip", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = true // Enable tooltip on recoverable errors. The tooltip include a way to enable asserts if they were disabled." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2522 + } + }, + { + "name": "ConfigDebugIsDebuggerPresent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Option to enable various debug tools showing buttons that will call the IM_DEBUG_BREAK() macro.", + "// - The Item Picker tool will be available regardless of this being enabled, in order to maximize its discoverability.", + "// - Requires a debugger being attached, otherwise IM_DEBUG_BREAK() options will appear to crash your application.", + "// e.g. io.ConfigDebugIsDebuggerPresent = ::IsDebuggerPresent() on Win32, or refer to ImOsIsDebuggerPresent() imgui_test_engine/imgui_te_utils.cpp for a Unix compatible version)." + ], + "attached": "// = false // Enable various tools calling IM_DEBUG_BREAK()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2528 + } + }, + { + "name": "ConfigDebugHighlightIdConflicts", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Tools to detect code submitting items with conflicting/duplicate IDs", + "// - Code should use PushID()/PopID() in loops, or append \"##xx\" to same-label identifiers.", + "// - Empty label e.g. Button(\"\") == same ID as parent widget/node. Use Button(\"##xx\") instead!", + "// - See FAQ https://github.com/ocornut/imgui/blob/master/docs/FAQ.md#q-about-the-id-stack-system" + ], + "attached": "// = true // Highlight and show an error message popup when multiple items have conflicting identifiers." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2534 + } + }, + { + "name": "ConfigDebugHighlightIdConflictsShowItemPicker", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "//=true // Show \"Item Picker\" button in aforementioned popup." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2535 + } + }, + { + "name": "ConfigDebugBeginReturnValueOnce", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Tools to test correct Begin/End and BeginChild/EndChild behaviors.", + "// - Presently Begin()/End() and BeginChild()/EndChild() needs to ALWAYS be called in tandem, regardless of return value of BeginXXX()", + "// - This is inconsistent with other BeginXXX functions and create confusion for many users.", + "// - We expect to update the API eventually. In the meanwhile we provide tools to facilitate checking user-code behavior." + ], + "attached": "// = false // First-time calls to Begin()/BeginChild() will return false. NEEDS TO BE SET AT APPLICATION BOOT TIME if you don't want to miss windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2541 + } + }, + { + "name": "ConfigDebugBeginReturnValueLoop", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // Some calls to Begin()/BeginChild() will return false. Will cycle through window depths then repeat. Suggested use: add \"io.ConfigDebugBeginReturnValue = io.KeyShift\" in your main loop then occasionally press SHIFT. Windows should be flickering while running." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2542 + } + }, + { + "name": "ConfigDebugIgnoreFocusLoss", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Option to deactivate io.AddFocusEvent(false) handling.", + "// - May facilitate interactions with a debugger when focus loss leads to clearing inputs data.", + "// - Backends may have other side-effects on focus loss, so this will reduce side-effects but not necessary remove all of them." + ], + "attached": "// = false // Ignore io.AddFocusEvent(false), consequently not calling io.ClearInputKeys()/io.ClearInputMouse() in input processing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2547 + } + }, + { + "name": "ConfigDebugIniSettings", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Option to audit .ini data" + ], + "attached": "// = false // Save .ini data with extra comments (particularly helpful for Docking, but makes saving slower)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2550 + } + }, + { + "name": "BackendPlatformName", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "preceding": [ + "// Nowadays those would be stored in ImGuiPlatformIO but we are leaving them here for legacy reasons.", + "// Optional: Platform/Renderer backend name (informational only! will be displayed in About Window) + User data for backend/wrappers to store their own stuff." + ], + "attached": "// = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2559 + } + }, + { + "name": "BackendRendererName", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2560 + } + }, + { + "name": "BackendPlatformUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// = NULL // User data for platform backend" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2561 + } + }, + { + "name": "BackendRendererUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// = NULL // User data for renderer backend" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2562 + } + }, + { + "name": "BackendLanguageUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// = NULL // User data for non C++ programming language backend" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2563 + } + }, + { + "name": "WantCaptureMouse", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when Dear ImGui will use mouse inputs, in this case do not dispatch them to your main game/application (either way, always pass on mouse inputs to imgui). (e.g. unclicked mouse is hovering over an imgui window, widget is active, mouse was clicked over an imgui window, etc.)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2597 + } + }, + { + "name": "WantCaptureKeyboard", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when Dear ImGui will use keyboard inputs, in this case do not dispatch them to your main game/application (either way, always pass keyboard inputs to imgui). (e.g. InputText active, or an imgui window is focused and navigation is enabled, etc.)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2598 + } + }, + { + "name": "WantTextInput", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Mobile/console: when set, you may display an on-screen keyboard. This is set by Dear ImGui when it wants textual keyboard input to happen (e.g. when a InputText widget is active)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2599 + } + }, + { + "name": "WantSetMousePos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// MousePos has been altered, backend should reposition mouse on next frame. Rarely used! Set only when io.ConfigNavMoveSetMousePos is enabled." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2600 + } + }, + { + "name": "WantSaveIniSettings", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// When manual .ini load/save is active (io.IniFilename == NULL), this will be set to notify your application that you can call SaveIniSettingsToMemory() and save yourself. Important: clear io.WantSaveIniSettings yourself after saving!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2601 + } + }, + { + "name": "NavActive", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Keyboard/Gamepad navigation is currently allowed (will handle ImGuiKey_NavXXX events) = a window is focused and it doesn't use the ImGuiWindowFlags_NoNavInputs flag." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2602 + } + }, + { + "name": "NavVisible", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Keyboard/Gamepad navigation highlight is visible and allowed (will handle ImGuiKey_NavXXX events)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2603 + } + }, + { + "name": "Framerate", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Estimate of application framerate (rolling average over 60 frames, based on io.DeltaTime), in frame per second. Solely for convenience. Slow applications may not want to use a moving average or may want to reset underlying buffers occasionally." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2604 + } + }, + { + "name": "MetricsRenderVertices", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Vertices output during last call to Render()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2605 + } + }, + { + "name": "MetricsRenderIndices", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Indices output during last call to Render() = number of triangles * 3" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2606 + } + }, + { + "name": "MetricsRenderWindows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of visible windows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2607 + } + }, + { + "name": "MetricsActiveWindows", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of active windows" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2608 + } + }, + { + "name": "MouseDelta", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Mouse delta. Note that this is zero if either current or previous position are invalid (-FLT_MAX,-FLT_MAX), so a disappearing/reappearing mouse won't have a huge delta." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2609 + } + }, + { + "name": "Ctx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "comments": { + "attached": "// Parent UI context (needs to be set explicitly by parent)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2615 + } + }, + { + "name": "MousePos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "preceding": [ + "// Main Input State", + "// (this block used to be written by backend, since 1.87 it is best to NOT write to those directly, call the AddXXX functions above instead)", + "// (reading from those variables is fair game, as they are extremely unlikely to be moving anywhere)" + ], + "attached": "// Mouse position, in pixels. Set to ImVec2(-FLT_MAX, -FLT_MAX) if mouse is unavailable (on another screen, etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2620 + } + }, + { + "name": "MouseDown", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "bool[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "comments": { + "attached": "// Mouse buttons: 0=left, 1=right, 2=middle + extras (ImGuiMouseButton_COUNT == 5). Dear ImGui mostly uses left and right buttons. Other buttons allow us to track if the mouse is being used by your application + available to user as a convenience via IsMouse** API." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2621 + } + }, + { + "name": "MouseWheel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Mouse wheel Vertical: 1 unit scrolls about 5 lines text. >0 scrolls Up, <0 scrolls Down. Hold SHIFT to turn vertical scroll into horizontal scroll." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2622 + } + }, + { + "name": "MouseWheelH", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Mouse wheel Horizontal. >0 scrolls Left, <0 scrolls Right. Most users don't have a mouse with a horizontal wheel, may not be filled by all backends." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2623 + } + }, + { + "name": "MouseSource", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiMouseSource", + "description": { + "kind": "User", + "name": "ImGuiMouseSource" + } + }, + "comments": { + "attached": "// Mouse actual input peripheral (Mouse/TouchScreen/Pen)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2624 + } + }, + { + "name": "MouseHoveredViewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// (Optional) Modify using io.AddMouseViewportEvent(). With multi-viewports: viewport the OS mouse is hovering. If possible _IGNORING_ viewports with the ImGuiViewportFlags_NoInputs flag is much better (few backends can handle that). Set io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport if you can provide this info. If you don't imgui will infer the value using the rectangles and last focused time of the viewports it knows about (ignoring other OS windows)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2625 + } + }, + { + "name": "KeyCtrl", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Keyboard modifier down: Ctrl (non-macOS), Cmd (macOS)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2626 + } + }, + { + "name": "KeyShift", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Keyboard modifier down: Shift" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2627 + } + }, + { + "name": "KeyAlt", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Keyboard modifier down: Alt" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2628 + } + }, + { + "name": "KeySuper", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Keyboard modifier down: Windows/Super (non-macOS), Ctrl (macOS)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2629 + } + }, + { + "name": "KeyMods", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "comments": { + "preceding": [ + "// Other state maintained from data above + IO function calls" + ], + "attached": "// Key mods flags (any of ImGuiMod_Ctrl/ImGuiMod_Shift/ImGuiMod_Alt/ImGuiMod_Super flags, same as io.KeyCtrl/KeyShift/KeyAlt/KeySuper but merged into flags. Read-only, updated by NewFrame()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2632 + } + }, + { + "name": "KeysData", + "is_array": true, + "array_bounds": "ImGuiKey_NamedKey_COUNT", + "is_anonymous": false, + "type": { + "declaration": "ImGuiKeyData[ImGuiKey_NamedKey_COUNT]", + "description": { + "kind": "Array", + "bounds": "ImGuiKey_NamedKey_COUNT", + "inner_type": { + "kind": "User", + "name": "ImGuiKeyData" + } + } + }, + "comments": { + "attached": "// Key state for all known keys. MUST use 'key - ImGuiKey_NamedKey_BEGIN' as index. Use IsKeyXXX() functions to access this." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2633 + } + }, + { + "name": "WantCaptureMouseUnlessPopupClose", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Alternative to WantCaptureMouse: (WantCaptureMouse == true && WantCaptureMouseUnlessPopupClose == false) when a click over void is expected to close a popup." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2634 + } + }, + { + "name": "MousePosPrev", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Previous mouse position (note that MouseDelta is not necessary == MousePos-MousePosPrev, in case either position is invalid)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2635 + } + }, + { + "name": "MouseClickedPos", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "ImVec2[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "comments": { + "attached": "// Position at time of clicking" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2636 + } + }, + { + "name": "MouseClickedTime", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "double[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "double" + } + } + }, + "comments": { + "attached": "// Time of last click (used to figure out double-click)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2637 + } + }, + { + "name": "MouseClicked", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "bool[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "comments": { + "attached": "// Mouse button went from !Down to Down (same as MouseClickedCount[x] != 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2638 + } + }, + { + "name": "MouseDoubleClicked", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "bool[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "comments": { + "attached": "// Has mouse button been double-clicked? (same as MouseClickedCount[x] == 2)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2639 + } + }, + { + "name": "MouseClickedCount", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "ImU16[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "User", + "name": "ImU16" + } + } + }, + "comments": { + "attached": "// == 0 (not clicked), == 1 (same as MouseClicked[]), == 2 (double-clicked), == 3 (triple-clicked) etc. when going from !Down to Down" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2640 + } + }, + { + "name": "MouseClickedLastCount", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "ImU16[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "User", + "name": "ImU16" + } + } + }, + "comments": { + "attached": "// Count successive number of clicks. Stays valid after mouse release. Reset after another click is done." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2641 + } + }, + { + "name": "MouseReleased", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "bool[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "comments": { + "attached": "// Mouse button went from Down to !Down" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2642 + } + }, + { + "name": "MouseReleasedTime", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "double[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "double" + } + } + }, + "comments": { + "attached": "// Time of last released (rarely used! but useful to handle delayed single-click when trying to disambiguate them from double-click)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2643 + } + }, + { + "name": "MouseDownOwned", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "bool[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "comments": { + "attached": "// Track if button was clicked inside a dear imgui window or over void blocked by a popup. We don't request mouse capture from the application if click started outside ImGui bounds." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2644 + } + }, + { + "name": "MouseDownOwnedUnlessPopupClose", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "bool[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "comments": { + "attached": "// Track if button was clicked inside a dear imgui window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2645 + } + }, + { + "name": "MouseWheelRequestAxisSwap", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// On a non-Mac system, holding SHIFT requests WheelY to perform the equivalent of a WheelX event. On a Mac system this is already enforced by the system." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2646 + } + }, + { + "name": "MouseCtrlLeftAsRightClick", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// (OSX) Set to true when the current click was a Ctrl+click that spawned a simulated right click" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2647 + } + }, + { + "name": "MouseDownDuration", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "float[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "comments": { + "attached": "// Duration the mouse button has been down (0.0f == just clicked)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2648 + } + }, + { + "name": "MouseDownDurationPrev", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "float[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "comments": { + "attached": "// Previous time the mouse button has been down" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2649 + } + }, + { + "name": "MouseDragMaxDistanceAbs", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "ImVec2[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "comments": { + "attached": "// Maximum distance, absolute, on each axis, of how much mouse has traveled from the clicking point" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2650 + } + }, + { + "name": "MouseDragMaxDistanceSqr", + "is_array": true, + "array_bounds": "5", + "is_anonymous": false, + "type": { + "declaration": "float[5]", + "description": { + "kind": "Array", + "bounds": "5", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "comments": { + "attached": "// Squared maximum distance of how much mouse has traveled from the clicking point (used for moving thresholds)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2651 + } + }, + { + "name": "PenPressure", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Touch/Pen pressure (0.0f to 1.0f, should be >0.0f only when MouseDown[0] == true). Helper storage currently unused by Dear ImGui." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2652 + } + }, + { + "name": "AppFocusLost", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Only modify via AddFocusEvent()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2653 + } + }, + { + "name": "AppAcceptingEvents", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Only modify via SetAppAcceptingEvents()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2654 + } + }, + { + "name": "InputQueueSurrogate", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImWchar16", + "description": { + "kind": "User", + "name": "ImWchar16" + } + }, + "comments": { + "attached": "// For AddInputCharacterUTF16()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2655 + } + }, + { + "name": "InputQueueCharacters", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImWchar", + "description": { + "kind": "User", + "name": "ImVector_ImWchar" + } + }, + "comments": { + "attached": "// Queue of _characters_ input (obtained by platform backend). Fill using AddInputCharacter() helper." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2656 + } + }, + { + "name": "FontGlobalScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Moved io.FontGlobalScale to style.FontScaleMain in 1.92 (June 2025)" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2669 + } + }, + { + "name": "GetClipboardTextFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char* (*GetClipboardTextFn)(void* user_data)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "GetClipboardTextFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Legacy: before 1.91.1, clipboard functions were stored in ImGuiIO instead of ImGuiPlatformIO.", + "// As this is will affect all users of custom engines/backends, we are providing proper legacy redirection (will obsolete)." + ] + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "SetClipboardTextFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*SetClipboardTextFn)(void* user_data, const char* text)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "SetClipboardTextFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "text", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "ClipboardUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2675 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2431 + } + }, + { + "name": "ImGuiInputTextCallbackData", + "original_fully_qualified_name": "ImGuiInputTextCallbackData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Ctx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "comments": { + "attached": "// Parent UI context" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2696 + } + }, + { + "name": "EventFlag", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "comments": { + "attached": "// One ImGuiInputTextFlags_Callback* // Read-only" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2697 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "comments": { + "attached": "// What user passed to InputText() // Read-only" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2698 + } + }, + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// What user passed to InputText() // Read-only" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2699 + } + }, + { + "name": "EventChar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "comments": { + "preceding": [ + "// Arguments for the different callback events", + "// - During Resize callback, Buf will be same as your input buffer.", + "// - However, during Completion/History/Always callback, Buf always points to our own internal data (it is not the same as your buffer)! Changes to it will be reflected into your own buffer shortly after the callback.", + "// - To modify the text buffer in a callback, prefer using the InsertChars() / DeleteChars() function. InsertChars() will take care of calling the resize callback if necessary.", + "// - If you know your edits are not going to resize the underlying buffer allocation, you may modify the contents of 'Buf[]' directly. You need to update 'BufTextLen' accordingly (0 <= BufTextLen < BufSize) and set 'BufDirty'' to true so InputText can update its internal state." + ], + "attached": "// Character input // Read-write // [CharFilter] Replace character with another one, or set to zero to drop. return 1 is equivalent to setting EventChar=0;" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2706 + } + }, + { + "name": "EventKey", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "comments": { + "attached": "// Key pressed (Up/Down/TAB) // Read-only // [Completion,History]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2707 + } + }, + { + "name": "Buf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "comments": { + "attached": "// Text buffer // Read-write // [Resize] Can replace pointer / [Completion,History,Always] Only write to pointed data, don't replace the actual pointer!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2708 + } + }, + { + "name": "BufTextLen", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Text length (in bytes) // Read-write // [Resize,Completion,History,Always] Exclude zero-terminator storage. In C land: == strlen(some_text), in C++ land: string.length()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2709 + } + }, + { + "name": "BufSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Buffer size (in bytes) = capacity+1 // Read-only // [Resize,Completion,History,Always] Include zero-terminator storage. In C land == ARRAYSIZE(my_char_array), in C++ land: string.capacity()+1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2710 + } + }, + { + "name": "BufDirty", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set if you modify Buf/BufTextLen! // Write // [Completion,History,Always]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2711 + } + }, + { + "name": "CursorPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// // Read-write // [Completion,History,Always]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2712 + } + }, + { + "name": "SelectionStart", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// // Read-write // [Completion,History,Always] == to SelectionEnd when no selection)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2713 + } + }, + { + "name": "SelectionEnd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// // Read-write // [Completion,History,Always]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2714 + } + } + ], + "comments": { + "preceding": [ + "// Shared state of InputText(), passed as an argument to your callback when a ImGuiInputTextFlags_Callback* flag is used.", + "// The callback function should return 0 by default.", + "// Callbacks (follow a flag name and see comments in ImGuiInputTextFlags_ declarations for more details)", + "// - ImGuiInputTextFlags_CallbackEdit: Callback on buffer edit. Note that InputText() already returns true on edit + you can always use IsItemEdited(). The callback is useful to manipulate the underlying buffer while focus is active.", + "// - ImGuiInputTextFlags_CallbackAlways: Callback on each iteration", + "// - ImGuiInputTextFlags_CallbackCompletion: Callback on pressing TAB", + "// - ImGuiInputTextFlags_CallbackHistory: Callback on pressing Up/Down arrows", + "// - ImGuiInputTextFlags_CallbackCharFilter: Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or discard, or return 1 in callback to discard.", + "// - ImGuiInputTextFlags_CallbackResize: Callback on buffer capacity changes request (beyond 'buf_size' parameter value), allowing the string to grow." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2694 + } + }, + { + "name": "ImGuiSizeCallbackData", + "original_fully_qualified_name": "ImGuiSizeCallbackData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Read-only. What user passed to SetNextWindowSizeConstraints(). Generally store an integer or float in here (need reinterpret_cast<>)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2730 + } + }, + { + "name": "Pos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Read-only. Window position, for reference." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2731 + } + }, + { + "name": "CurrentSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Read-only. Current window size." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2732 + } + }, + { + "name": "DesiredSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Read-write. Desired size, based on user's mouse position. Write to this field to restrain resizing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2733 + } + } + ], + "comments": { + "preceding": [ + "// Resizing callback data to apply custom constraint. As enabled by SetNextWindowSizeConstraints(). Callback is called during the next Begin().", + "// NB: For basic min/max size constraint on each axis you don't need to use the callback! The SetNextWindowSizeConstraints() parameters are enough." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2728 + } + }, + { + "name": "ImGuiWindowClass", + "original_fully_qualified_name": "ImGuiWindowClass", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ClassId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// User data. 0 = Default class (unclassed). Windows of different classes cannot be docked with each others." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2745 + } + }, + { + "name": "ParentViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Hint for the platform backend. -1: use default. 0: request platform backend to not parent the platform. != 0: request platform backend to create a parent<>child relationship between the platform windows. Not conforming backends are free to e.g. parent every viewport to the main viewport or not." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2746 + } + }, + { + "name": "FocusRouteParentWindowId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID of parent window for shortcut focus route evaluation, e.g. Shortcut() call from Parent Window will succeed when this window is focused." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2747 + } + }, + { + "name": "ViewportFlagsOverrideSet", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportFlags", + "description": { + "kind": "User", + "name": "ImGuiViewportFlags" + } + }, + "comments": { + "attached": "// Viewport flags to set when a window of this class owns a viewport. This allows you to enforce OS decoration or task bar icon, override the defaults on a per-window basis." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2748 + } + }, + { + "name": "ViewportFlagsOverrideClear", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportFlags", + "description": { + "kind": "User", + "name": "ImGuiViewportFlags" + } + }, + "comments": { + "attached": "// Viewport flags to clear when a window of this class owns a viewport. This allows you to enforce OS decoration or task bar icon, override the defaults on a per-window basis." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2749 + } + }, + { + "name": "TabItemFlagsOverrideSet", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "comments": { + "attached": "// [EXPERIMENTAL] TabItem flags to set when a window of this class gets submitted into a dock node tab bar. May use with ImGuiTabItemFlags_Leading or ImGuiTabItemFlags_Trailing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2750 + } + }, + { + "name": "DockNodeFlagsOverrideSet", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "comments": { + "attached": "// [EXPERIMENTAL] Dock node flags to set when a window of this class is hosted by a dock node (it doesn't have to be selected!)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2751 + } + }, + { + "name": "DockingAlwaysTabBar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to true to enforce single floating windows of this class always having their own docking node (equivalent of setting the global io.ConfigDockingAlwaysTabBar)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2752 + } + }, + { + "name": "DockingAllowUnclassed", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set to true to allow windows of this class to be docked/merged with an unclassed window. // FIXME-DOCK: Move to DockNodeFlags override?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2753 + } + } + ], + "comments": { + "preceding": [ + "// [ALPHA] Rarely used / very advanced uses only. Use with SetNextWindowClass() and DockSpace() functions.", + "// Important: the content of this class is still highly WIP and likely to change and be refactored", + "// before we stabilize Docking features. Please be mindful if using this.", + "// Provide hints:", + "// - To the platform backend via altered viewport flags (enable/disable OS decoration, OS task bar icons, etc.)", + "// - To the platform backend for OS level parent/child relationships of viewport.", + "// - To the docking system for various options and filtering." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2743 + } + }, + { + "name": "ImGuiPayload", + "original_fully_qualified_name": "ImGuiPayload", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "preceding": [ + "// Members" + ], + "attached": "// Data (copied and owned by dear imgui)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2762 + } + }, + { + "name": "DataSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Data size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2763 + } + }, + { + "name": "SourceId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// [Internal]" + ], + "attached": "// Source item id" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2766 + } + }, + { + "name": "SourceParentId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Source parent id (if available)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2767 + } + }, + { + "name": "DataFrameCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Data timestamp" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2768 + } + }, + { + "name": "DataType", + "is_array": true, + "array_bounds": "32+1", + "is_anonymous": false, + "type": { + "declaration": "char[32+1]", + "description": { + "kind": "Array", + "bounds": "32+1", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "comments": { + "attached": "// Data type tag (short user-supplied string, 32 characters max)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2769 + } + }, + { + "name": "Preview", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when AcceptDragDropPayload() was called and mouse has been hovering the target item (nb: handle overlapping drag targets)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2770 + } + }, + { + "name": "Delivery", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when AcceptDragDropPayload() was called and mouse button is released over the target item." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2771 + } + } + ], + "comments": { + "preceding": [ + "// Data payload for Drag and Drop operations: AcceptDragDropPayload(), GetDragDropPayload()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2759 + } + }, + { + "name": "ImGuiTextFilter_ImGuiTextRange", + "original_fully_qualified_name": "ImGuiTextFilter::ImGuiTextRange", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "b", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2814 + } + }, + { + "name": "e", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2815 + } + } + ], + "comments": { + "preceding": [ + "// [Internal]" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2812 + } + }, + { + "name": "ImGuiTextFilter", + "original_fully_qualified_name": "ImGuiTextFilter", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "InputBuf", + "is_array": true, + "array_bounds": "256", + "is_anonymous": false, + "type": { + "declaration": "char[256]", + "description": { + "kind": "Array", + "bounds": "256", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2822 + } + }, + { + "name": "Filters", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiTextRange", + "description": { + "kind": "User", + "name": "ImVector_ImGuiTextRange" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2823 + } + }, + { + "name": "CountGrep", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2824 + } + } + ], + "comments": { + "preceding": [ + "// Helper: Parse and apply text filters. In format \"aaaaa[,bbbb][,ccccc]\"" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2802 + } + }, + { + "name": "ImGuiTextBuffer", + "original_fully_qualified_name": "ImGuiTextBuffer", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Buf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_char", + "description": { + "kind": "User", + "name": "ImVector_char" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2831 + } + } + ], + "comments": { + "preceding": [ + "// Helper: Growable text buffer for logging/accumulating text", + "// (this could be called 'ImGuiTextBuilder' / 'ImGuiStringBuilder')" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2829 + } + }, + { + "name": "ImGuiStoragePair", + "original_fully_qualified_name": "ImGuiStoragePair", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "key", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2852 + } + }, + { + "name": "__anonymous_type0", + "is_array": false, + "is_anonymous": true, + "type": { + "declaration": "__anonymous_type0", + "description": { + "kind": "User", + "name": "__anonymous_type0" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + } + ], + "comments": { + "preceding": [ + "// [Internal] Key+Value for ImGuiStorage" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2850 + } + }, + { + "name": "__anonymous_type0", + "original_fully_qualified_name": "ImGuiStoragePair::", + "kind": "union", + "by_value": false, + "forward_declaration": false, + "is_anonymous": true, + "fields": [ + { + "name": "val_i", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2853 + } + }, + { + "name": "val_f", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2853 + } + }, + { + "name": "val_p", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2853 + } + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2853 + } + }, + { + "name": "ImGuiStorage", + "original_fully_qualified_name": "ImGuiStorage", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiStoragePair", + "description": { + "kind": "User", + "name": "ImVector_ImGuiStoragePair" + } + }, + "comments": { + "preceding": [ + "// [Internal]" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 2870 + } + } + ], + "comments": { + "preceding": [ + "// Helper: Key->Value storage", + "// Typically you don't have to worry about this since a storage is held within each Window.", + "// We use it to e.g. store collapse state for a tree (Int 0/1)", + "// This is optimized for efficient lookup (dichotomy into a contiguous buffer) and rare insertion (typically tied to user interactions aka max once a frame)", + "// You can use it as custom user storage for temporary values. Declare your own storage if, for example:", + "// - You want to manipulate the open/close state of a particular sub-tree in your interface (tree node uses Int 0/1 to store their state).", + "// - You want to store custom debug data easily without adding or editing structures in your code (probably not efficient, but convenient)", + "// Types are NOT stored, so it is up to you to make sure your Key don't collide with different types." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2867 + } + }, + { + "name": "ImGuiListClipper", + "original_fully_qualified_name": "ImGuiListClipper", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Ctx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "comments": { + "attached": "// Parent UI context" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2926 + } + }, + { + "name": "DisplayStart", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// First item to display, updated by each call to Step()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2927 + } + }, + { + "name": "DisplayEnd", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// End of items to display (exclusive)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2928 + } + }, + { + "name": "ItemsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// [Internal] Number of items" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2929 + } + }, + { + "name": "ItemsHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// [Internal] Height of item after a first step and item submission can calculate it" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2930 + } + }, + { + "name": "StartPosY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "comments": { + "attached": "// [Internal] Cursor position at the time of Begin() or after table frozen rows are all processed" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2931 + } + }, + { + "name": "StartSeekOffsetY", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "comments": { + "attached": "// [Internal] Account for frozen rows in a table and initial loss of precision in very large windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2932 + } + }, + { + "name": "TempData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// [Internal] Internal data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2933 + } + } + ], + "comments": { + "preceding": [ + "// Helper: Manually clip large list of items.", + "// If you have lots evenly spaced items and you have random access to the list, you can perform coarse", + "// clipping based on visibility to only submit items that are in view.", + "// The clipper calculates the range of visible items and advance the cursor to compensate for the non-visible items we have skipped.", + "// (Dear ImGui already clip items based on their bounds but: it needs to first layout the item to do so, and generally", + "// fetching/submitting your own data incurs additional cost. Coarse clipping using ImGuiListClipper allows you to easily", + "// scale using lists with tens of thousands of items without a problem)", + "// Usage:", + "// ImGuiListClipper clipper;", + "// clipper.Begin(1000); // We have 1000 elements, evenly spaced.", + "// while (clipper.Step())", + "// for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)", + "// ImGui::Text(\"line number %d\", i);", + "// Generally what happens is:", + "// - Clipper lets you process the first element (DisplayStart = 0, DisplayEnd = 1) regardless of it being visible or not.", + "// - User code submit that one element.", + "// - Clipper can measure the height of the first element", + "// - Clipper calculate the actual range of elements to display based on the current clipping rectangle, position the cursor before the first visible element.", + "// - User code submit visible elements.", + "// - The clipper also handles various subtleties related to keyboard/gamepad navigation, wrapping etc." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2924 + } + }, + { + "name": "ImColor", + "original_fully_qualified_name": "ImColor", + "kind": "struct", + "by_value": true, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Value", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3026 + } + } + ], + "comments": { + "preceding": [ + "// Helper: ImColor() implicitly converts colors to either ImU32 (packed 4x1 byte) or ImVec4 (4x1 float)", + "// Prefer using IM_COL32() macros if you want a guaranteed compile-time ImU32 for usage with ImDrawList API.", + "// **Avoid storing ImColor! Store either u32 of ImVec4. This is not a full-featured color class. MAY OBSOLETE.", + "// **None of the ImGui API are using ImColor directly but you can use it as a convenience to pass colors in either ImU32 or ImVec4 formats. Explicitly cast to ImU32 or ImVec4 if needed." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3024 + } + }, + { + "name": "ImGuiMultiSelectIO", + "original_fully_qualified_name": "ImGuiMultiSelectIO", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Requests", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiSelectionRequest", + "description": { + "kind": "User", + "name": "ImVector_ImGuiSelectionRequest" + } + }, + "comments": { + "preceding": [ + "//------------------------------------------// BeginMultiSelect / EndMultiSelect" + ], + "attached": "// ms:w, app:r / ms:w app:r // Requests to apply to your selection data." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3112 + } + }, + { + "name": "RangeSrcItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// ms:w app:r / // (If using clipper) Begin: Source item (often the first selected item) must never be clipped: use clipper.IncludeItemByIndex() to ensure it is submitted." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3113 + } + }, + { + "name": "NavIdItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// ms:w, app:r / // (If using deletion) Last known SetNextItemSelectionUserData() value for NavId (if part of submitted items)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3114 + } + }, + { + "name": "NavIdSelected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// ms:w, app:r / app:r // (If using deletion) Last known selection state for NavId (if part of submitted items)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3115 + } + }, + { + "name": "RangeSrcReset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// app:w / ms:r // (If using deletion) Set before EndMultiSelect() to reset ResetSrcItem (e.g. if deleted selection)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3116 + } + }, + { + "name": "ItemsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// ms:w, app:r / app:r // 'int items_count' parameter to BeginMultiSelect() is copied here for convenience, allowing simpler calls to your ApplyRequests handler. Not used internally." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3117 + } + } + ], + "comments": { + "preceding": [ + "// Main IO structure returned by BeginMultiSelect()/EndMultiSelect().", + "// This mainly contains a list of selection requests.", + "// - Use 'Demo->Tools->Debug Log->Selection' to see requests as they happen.", + "// - Some fields are only useful if your list is dynamic and allows deletion (getting post-deletion focus/state right is shown in the demo)", + "// - Below: who reads/writes each fields? 'r'=read, 'w'=write, 'ms'=multi-select code, 'app'=application/user code." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3109 + } + }, + { + "name": "ImGuiSelectionRequest", + "original_fully_qualified_name": "ImGuiSelectionRequest", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Type", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionRequestType", + "description": { + "kind": "User", + "name": "ImGuiSelectionRequestType" + } + }, + "comments": { + "preceding": [ + "//------------------------------------------// BeginMultiSelect / EndMultiSelect" + ], + "attached": "// ms:w, app:r / ms:w, app:r // Request type. You'll most often receive 1 Clear + 1 SetRange with a single-item range." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3132 + } + }, + { + "name": "Selected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// ms:w, app:r / ms:w, app:r // Parameter for SetAll/SetRange requests (true = select, false = unselect)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3133 + } + }, + { + "name": "RangeDirection", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// / ms:w app:r // Parameter for SetRange request: +1 when RangeFirstItem comes before RangeLastItem, -1 otherwise. Useful if you want to preserve selection order on a backward Shift+Click." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3134 + } + }, + { + "name": "RangeFirstItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// / ms:w, app:r // Parameter for SetRange request (this is generally == RangeSrcItem when shift selecting from top to bottom)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3135 + } + }, + { + "name": "RangeLastItem", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "comments": { + "attached": "// / ms:w, app:r // Parameter for SetRange request (this is generally == RangeSrcItem when shift selecting from bottom to top). Inclusive!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3136 + } + } + ], + "comments": { + "preceding": [ + "// Selection request item" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3129 + } + }, + { + "name": "ImGuiSelectionBasicStorage", + "original_fully_qualified_name": "ImGuiSelectionBasicStorage", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Members" + ], + "attached": "// // Number of selected items, maintained by this helper." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3158 + } + }, + { + "name": "PreserveOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// = false // GetNextSelectedItem() will return ordered selection (currently implemented by two additional sorts of selection. Could be improved)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3159 + } + }, + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// = NULL // User data for use by adapter function // e.g. selection.UserData = (void*)my_items;" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3160 + } + }, + { + "name": "AdapterIndexToStorageId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID (*AdapterIndexToStorageId)(ImGuiSelectionBasicStorage* self, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "AdapterIndexToStorageId", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "User", + "name": "ImGuiID" + }, + "parameters": [ + { + "kind": "Type", + "name": "self", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "comments": { + "attached": "// e.g. selection.AdapterIndexToStorageId = [](ImGuiSelectionBasicStorage* self, int idx) { return ((MyItems**)self->UserData)[idx]->ID; };" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "_SelectionOrder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// [Internal] Increasing counter to store selection order" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3162 + } + }, + { + "name": "_Storage", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// [Internal] Selection set. Think of this as similar to e.g. std::set. Prefer not accessing directly: iterate with GetNextSelectedItem()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3163 + } + } + ], + "comments": { + "preceding": [ + "// Optional helper to store multi-selection state + apply multi-selection requests.", + "// - Used by our demos and provided as a convenience to easily implement basic multi-selection.", + "// - Iterate selection with 'void* it = NULL; ImGuiID id; while (selection.GetNextSelectedItem(&it, &id)) { ... }'", + "// Or you can check 'if (Contains(id)) { ... }' for each possible object if their number is not too high to iterate.", + "// - USING THIS IS NOT MANDATORY. This is only a helper and not a required API.", + "// To store a multi-selection, in your application you could:", + "// - Use this helper as a convenience. We use our simple key->value ImGuiStorage as a std::set replacement.", + "// - Use your own external storage: e.g. std::set, std::vector, interval trees, intrusively stored selection etc.", + "// In ImGuiSelectionBasicStorage we:", + "// - always use indices in the multi-selection API (passed to SetNextItemSelectionUserData(), retrieved in ImGuiMultiSelectIO)", + "// - use the AdapterIndexToStorageId() indirection layer to abstract how persistent selection data is derived from an index.", + "// - use decently optimized logic to allow queries and insertion of very large selection sets.", + "// - do not preserve selection order.", + "// Many combinations are possible depending on how you prefer to store your items and how you prefer to store your selection.", + "// Large applications are likely to eventually want to get rid of this indirection layer and do their own thing.", + "// See https://github.com/ocornut/imgui/wiki/Multi-Select for details and pseudo-code using this helper." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3155 + } + }, + { + "name": "ImGuiSelectionExternalStorage", + "original_fully_qualified_name": "ImGuiSelectionExternalStorage", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "preceding": [ + "// Members" + ], + "attached": "// User data for use by adapter function // e.g. selection.UserData = (void*)my_items;" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3181 + } + }, + { + "name": "AdapterSetItemSelected", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*AdapterSetItemSelected)(ImGuiSelectionExternalStorage* self, int idx, bool selected)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionExternalStorage*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionExternalStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "selected", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "AdapterSetItemSelected", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "self", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionExternalStorage" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + { + "kind": "Type", + "name": "selected", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + ] + } + } + } + }, + "comments": { + "attached": "// e.g. AdapterSetItemSelected = [](ImGuiSelectionExternalStorage* self, int idx, bool selected) { ((MyItems**)self->UserData)[idx]->Selected = selected; }" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + } + ], + "comments": { + "preceding": [ + "// Optional helper to apply multi-selection requests to existing randomly accessible storage.", + "// Convenient if you want to quickly wire multi-select API on e.g. an array of bool or items storing their own selection state." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3178 + } + }, + { + "name": "ImDrawCmd", + "original_fully_qualified_name": "ImDrawCmd", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "comments": { + "attached": "// 4*4 // Clipping rectangle (x1, y1, x2, y2). Subtract ImDrawData->DisplayPos to get clipping rectangle in \"viewport\" coordinates" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3230 + } + }, + { + "name": "TexRef", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "comments": { + "attached": "// 16 // Reference to a font/texture atlas (where backend called ImTextureData::SetTexID()) or to a user-provided texture ID (via e.g. ImGui::Image() calls). Both will lead to a ImTextureID value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3231 + } + }, + { + "name": "VtxOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 4 // Start offset in vertex buffer. ImGuiBackendFlags_RendererHasVtxOffset: always 0, otherwise may be >0 to support meshes larger than 64K vertices with 16-bit indices." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3232 + } + }, + { + "name": "IdxOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 4 // Start offset in index buffer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3233 + } + }, + { + "name": "ElemCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 4 // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[]." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3234 + } + }, + { + "name": "UserCallback", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawCallback", + "description": { + "kind": "User", + "name": "ImDrawCallback" + } + }, + "comments": { + "attached": "// 4-8 // If != NULL, call the function instead of rendering the vertices. clip_rect and texture_id will be set normally." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3235 + } + }, + { + "name": "UserCallbackData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// 4-8 // Callback user data (when UserCallback != NULL). If called AddCallback() with size == 0, this is a copy of the AddCallback() argument. If called AddCallback() with size > 0, this is pointing to a buffer where data is stored." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3236 + } + }, + { + "name": "UserCallbackDataSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// 4 // Size of callback user data when using storage, otherwise 0." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3237 + } + }, + { + "name": "UserCallbackDataOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// 4 // [Internal] Offset of callback user data when using storage, otherwise -1." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3238 + } + } + ], + "comments": { + "preceding": [ + "// Typically, 1 command = 1 GPU draw call (unless command is a callback)", + "// - VtxOffset: When 'io.BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset' is enabled,", + "// this fields allow us to render meshes larger than 64K vertices while keeping 16-bit indices.", + "// Backends made for <1.71. will typically ignore the VtxOffset fields.", + "// - The ClipRect/TexRef/VtxOffset fields must be contiguous as we memcmp() them together (this is asserted for)." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3228 + } + }, + { + "name": "ImDrawVert", + "original_fully_qualified_name": "ImDrawVert", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "pos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3251 + } + }, + { + "name": "uv", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3252 + } + }, + { + "name": "col", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3253 + } + } + ], + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3249 + } + }, + { + "name": "ImDrawCmdHeader", + "original_fully_qualified_name": "ImDrawCmdHeader", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ClipRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3266 + } + }, + { + "name": "TexRef", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3267 + } + }, + { + "name": "VtxOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3268 + } + } + ], + "comments": { + "preceding": [ + "// [Internal] For use by ImDrawList" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3264 + } + }, + { + "name": "ImDrawChannel", + "original_fully_qualified_name": "ImDrawChannel", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "_CmdBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawCmd", + "description": { + "kind": "User", + "name": "ImVector_ImDrawCmd" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3274 + } + }, + { + "name": "_IdxBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawIdx", + "description": { + "kind": "User", + "name": "ImVector_ImDrawIdx" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3275 + } + } + ], + "comments": { + "preceding": [ + "// [Internal] For use by ImDrawListSplitter" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3272 + } + }, + { + "name": "ImDrawListSplitter", + "original_fully_qualified_name": "ImDrawListSplitter", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "_Current", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Current channel number (0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3282 + } + }, + { + "name": "_Count", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of active channels (1+)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3283 + } + }, + { + "name": "_Channels", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawChannel", + "description": { + "kind": "User", + "name": "ImVector_ImDrawChannel" + } + }, + "comments": { + "attached": "// Draw channels (not resized down so _Count might be < Channels.Size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3284 + } + } + ], + "comments": { + "preceding": [ + "// Split/Merge functions are used to split the draw list into different layers which can be drawn into out of order.", + "// This is used by the Columns/Tables API, so items of each column can be batched together in a same draw call." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3280 + } + }, + { + "name": "ImDrawList", + "original_fully_qualified_name": "ImDrawList", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "CmdBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawCmd", + "description": { + "kind": "User", + "name": "ImVector_ImDrawCmd" + } + }, + "comments": { + "preceding": [ + "// This is what you have to render" + ], + "attached": "// Draw commands. Typically 1 command = 1 GPU draw call, unless the command is a callback." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3338 + } + }, + { + "name": "IdxBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawIdx", + "description": { + "kind": "User", + "name": "ImVector_ImDrawIdx" + } + }, + "comments": { + "attached": "// Index buffer. Each command consume ImDrawCmd::ElemCount of those" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3339 + } + }, + { + "name": "VtxBuffer", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawVert", + "description": { + "kind": "User", + "name": "ImVector_ImDrawVert" + } + }, + "comments": { + "attached": "// Vertex buffer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3340 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListFlags", + "description": { + "kind": "User", + "name": "ImDrawListFlags" + } + }, + "comments": { + "attached": "// Flags, you may poke into these to adjust anti-aliasing settings per-primitive." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3341 + } + }, + { + "name": "_VtxCurrentIdx", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "preceding": [ + "// [Internal, used while building lists]" + ], + "attached": "// [Internal] generally == VtxBuffer.Size unless we are past 64K vertices, in which case this gets reset to 0." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3344 + } + }, + { + "name": "_Data", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListSharedData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawListSharedData" + } + } + }, + "comments": { + "attached": "// Pointer to shared draw data (you can use ImGui::GetDrawListSharedData() to get the one from current ImGui context)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3345 + } + }, + { + "name": "_VtxWritePtr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawVert*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawVert" + } + } + }, + "comments": { + "attached": "// [Internal] point within VtxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3346 + } + }, + { + "name": "_IdxWritePtr", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawIdx*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawIdx" + } + } + }, + "comments": { + "attached": "// [Internal] point within IdxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3347 + } + }, + { + "name": "_Path", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImVec2", + "description": { + "kind": "User", + "name": "ImVector_ImVec2" + } + }, + "comments": { + "attached": "// [Internal] current path building" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3348 + } + }, + { + "name": "_CmdHeader", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawCmdHeader", + "description": { + "kind": "User", + "name": "ImDrawCmdHeader" + } + }, + "comments": { + "attached": "// [Internal] template of active commands. Fields should match those of CmdBuffer.back()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3349 + } + }, + { + "name": "_Splitter", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawListSplitter", + "description": { + "kind": "User", + "name": "ImDrawListSplitter" + } + }, + "comments": { + "attached": "// [Internal] for channels api (note: prefer using your own persistent instance of ImDrawListSplitter!)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3350 + } + }, + { + "name": "_ClipRectStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImVec4", + "description": { + "kind": "User", + "name": "ImVector_ImVec4" + } + }, + "comments": { + "attached": "// [Internal]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3351 + } + }, + { + "name": "_TextureStack", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImTextureRef", + "description": { + "kind": "User", + "name": "ImVector_ImTextureRef" + } + }, + "comments": { + "attached": "// [Internal]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3352 + } + }, + { + "name": "_CallbacksDataBuf", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImU8", + "description": { + "kind": "User", + "name": "ImVector_ImU8" + } + }, + "comments": { + "attached": "// [Internal]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3353 + } + }, + { + "name": "_FringeScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// [Internal] anti-alias fringe is scaled by this value, this helps to keep things sharp while zooming at vertex buffer content" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3354 + } + }, + { + "name": "_OwnerName", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Pointer to owner window's name for debugging" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3355 + } + } + ], + "comments": { + "preceding": [ + "// Draw command list", + "// This is the low-level list of polygons that ImGui:: functions are filling. At the end of the frame,", + "// all command lists are passed to your ImGuiIO::RenderDrawListFn function for rendering.", + "// Each dear imgui window contains its own ImDrawList. You can use ImGui::GetWindowDrawList() to", + "// access the current window draw list and draw custom primitives.", + "// You can interleave normal ImGui:: calls and adding primitives to the current draw list.", + "// In single viewport mode, top-left is == GetMainViewport()->Pos (generally 0,0), bottom-right is == GetMainViewport()->Pos+Size (generally io.DisplaySize).", + "// You are totally free to apply whatever transformation matrix you want to the data (depending on the use of the transformation you may want to apply it to ClipRect as well!)", + "// Important: Primitives are always added to the list and not culled (culling is done at higher-level by ImGui:: functions), if you use this API a lot consider coarse culling your drawn objects." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3335 + } + }, + { + "name": "ImDrawData", + "original_fully_qualified_name": "ImDrawData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Valid", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Only valid after Render() is called and before the next NewFrame() is called." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3495 + } + }, + { + "name": "CmdListsCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// == CmdLists.Size. (OBSOLETE: exists for legacy reasons). Number of ImDrawList* to render." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3496 + } + }, + { + "name": "TotalIdxCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// For convenience, sum of all ImDrawList's IdxBuffer.Size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3497 + } + }, + { + "name": "TotalVtxCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// For convenience, sum of all ImDrawList's VtxBuffer.Size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3498 + } + }, + { + "name": "CmdLists", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawListPtr", + "description": { + "kind": "User", + "name": "ImVector_ImDrawListPtr" + } + }, + "comments": { + "attached": "// Array of ImDrawList* to render. The ImDrawLists are owned by ImGuiContext and only pointed to from here." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3499 + } + }, + { + "name": "DisplayPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Top-left position of the viewport to render (== top-left of the orthogonal projection matrix to use) (== GetMainViewport()->Pos for the main viewport, == (0.0) in most single-viewport applications)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3500 + } + }, + { + "name": "DisplaySize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Size of the viewport to render (== GetMainViewport()->Size for the main viewport, == io.DisplaySize in most single-viewport applications)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3501 + } + }, + { + "name": "FramebufferScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Amount of pixels for each unit of DisplaySize. Copied from viewport->FramebufferScale (== io.DisplayFramebufferScale for main viewport). Generally (1,1) on normal display, (2,2) on OSX with Retina display." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3502 + } + }, + { + "name": "OwnerViewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "comments": { + "attached": "// Viewport carrying the ImDrawData instance, might be of use to the renderer (generally not)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3503 + } + }, + { + "name": "Textures", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImTextureDataPtr*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_ImTextureDataPtr" + } + } + }, + "comments": { + "attached": "// List of textures to update. Most of the times the list is shared by all ImDrawData, has only 1 texture and it doesn't need any update. This almost always points to ImGui::GetPlatformIO().Textures[]. May be overriden or set to NULL if you want to manually update textures." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3504 + } + } + ], + "comments": { + "preceding": [ + "// All draw data to render a Dear ImGui frame", + "// (NB: the style and the naming convention here is a little inconsistent, we currently preserve them for backward compatibility purpose,", + "// as this is one of the oldest structure exposed by the library! Basically, ImDrawList == CmdList)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3493 + } + }, + { + "name": "ImTextureRect", + "original_fully_qualified_name": "ImTextureRect", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "x", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Upper-left coordinates of rectangle to update" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3547 + } + }, + { + "name": "y", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Upper-left coordinates of rectangle to update" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3547 + } + }, + { + "name": "w", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Size of rectangle to update (in pixels)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3548 + } + }, + { + "name": "h", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Size of rectangle to update (in pixels)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3548 + } + } + ], + "comments": { + "preceding": [ + "// Coordinates of a rectangle within a texture.", + "// When a texture is in ImTextureStatus_WantUpdates state, we provide a list of individual rectangles to copy to the graphics system.", + "// You may use ImTextureData::Updates[] for the list, or ImTextureData::UpdateBox for a single bounding box." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3545 + } + }, + { + "name": "ImTextureData", + "original_fully_qualified_name": "ImTextureData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "UniqueID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "//------------------------------------------ core / backend ---------------------------------------" + ], + "attached": "// w - // [DEBUG] Sequential index to facilitate identifying a texture when debugging/printing. Unique per atlas." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3561 + } + }, + { + "name": "Status", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureStatus", + "description": { + "kind": "User", + "name": "ImTextureStatus" + } + }, + "comments": { + "attached": "// rw rw // ImTextureStatus_OK/_WantCreate/_WantUpdates/_WantDestroy. Always use SetStatus() to modify!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3562 + } + }, + { + "name": "BackendUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// - rw // Convenience storage for backend. Some backends may have enough with TexID." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3563 + } + }, + { + "name": "TexID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureID", + "description": { + "kind": "User", + "name": "ImTextureID" + } + }, + "comments": { + "attached": "// r w // Backend-specific texture identifier. Always use SetTexID() to modify! The identifier will stored in ImDrawCmd::GetTexID() and passed to backend's RenderDrawData function." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3564 + } + }, + { + "name": "Format", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "comments": { + "attached": "// w r // ImTextureFormat_RGBA32 (default) or ImTextureFormat_Alpha8" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3565 + } + }, + { + "name": "Width", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// w r // Texture width" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3566 + } + }, + { + "name": "Height", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// w r // Texture height" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3567 + } + }, + { + "name": "BytesPerPixel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// w r // 4 or 1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3568 + } + }, + { + "name": "Pixels", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char" + } + } + }, + "comments": { + "attached": "// w r // Pointer to buffer holding 'Width*Height' pixels and 'Width*Height*BytesPerPixels' bytes." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3569 + } + }, + { + "name": "UsedRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRect", + "description": { + "kind": "User", + "name": "ImTextureRect" + } + }, + "comments": { + "attached": "// w r // Bounding box encompassing all past and queued Updates[]." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3570 + } + }, + { + "name": "UpdateRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRect", + "description": { + "kind": "User", + "name": "ImTextureRect" + } + }, + "comments": { + "attached": "// w r // Bounding box encompassing all queued Updates[]." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3571 + } + }, + { + "name": "Updates", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImTextureRect", + "description": { + "kind": "User", + "name": "ImVector_ImTextureRect" + } + }, + "comments": { + "attached": "// w r // Array of individual updates." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3572 + } + }, + { + "name": "UnusedFrames", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// w r // In order to facilitate handling Status==WantDestroy in some backend: this is a count successive frames where the texture was not used. Always >0 when Status==WantDestroy." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3573 + } + }, + { + "name": "RefCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// w r // Number of contexts using this texture. Used during backend shutdown." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3574 + } + }, + { + "name": "UseColors", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// w r // Tell whether our texture data is known to use colors (rather than just white + alpha)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3575 + } + }, + { + "name": "WantDestroyNextFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// rw - // [Internal] Queued to set ImTextureStatus_WantDestroy next frame. May still be used in the current frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3576 + } + } + ], + "comments": { + "preceding": [ + "// Specs and pixel storage for a texture used by Dear ImGui.", + "// This is only useful for (1) core library and (2) backends. End-user/applications do not need to care about this.", + "// Renderer Backends will create a GPU-side version of this.", + "// Why does we store two identifiers: TexID and BackendUserData?", + "// - ImTextureID TexID = lower-level identifier stored in ImDrawCmd. ImDrawCmd can refer to textures not created by the backend, and for which there's no ImTextureData.", + "// - void* BackendUserData = higher-level opaque storage for backend own book-keeping. Some backends may have enough with TexID and not need both.", + "// In columns below: who reads/writes each fields? 'r'=read, 'w'=write, 'core'=main library, 'backend'=renderer backend" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3558 + } + }, + { + "name": "ImFontConfig", + "original_fully_qualified_name": "ImFontConfig", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Name", + "is_array": true, + "array_bounds": "40", + "is_anonymous": false, + "type": { + "declaration": "char[40]", + "description": { + "kind": "Array", + "bounds": "40", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "comments": { + "preceding": [ + "// Data Source" + ], + "attached": "// // Name (strictly to ease debugging, hence limited size buffer)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3603 + } + }, + { + "name": "FontData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// // TTF/OTF data" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3604 + } + }, + { + "name": "FontDataSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// // TTF/OTF data size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3605 + } + }, + { + "name": "FontDataOwnedByAtlas", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// true // TTF/OTF data ownership taken by the container ImFontAtlas (will delete memory itself)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3606 + } + }, + { + "name": "MergeMode", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "preceding": [ + "// Options" + ], + "attached": "// false // Merge into previous ImFont, so you can combine multiple inputs font into one ImFont (e.g. ASCII font + icons + Japanese glyphs). You may want to use GlyphOffset.y when merge font of different heights." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3609 + } + }, + { + "name": "PixelSnapH", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// false // Align every glyph AdvanceX to pixel boundaries. Useful e.g. if you are merging a non-pixel aligned font with the default font. If enabled, you can set OversampleH/V to 1." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3610 + } + }, + { + "name": "PixelSnapV", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// true // Align Scaled GlyphOffset.y to pixel boundaries." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3611 + } + }, + { + "name": "OversampleH", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// 0 (2) // Rasterize at higher quality for sub-pixel positioning. 0 == auto == 1 or 2 depending on size. Note the difference between 2 and 3 is minimal. You can reduce this to 1 for large glyphs save memory. Read https://github.com/nothings/stb/blob/master/tests/oversample/README.md for details." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3612 + } + }, + { + "name": "OversampleV", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImS8", + "description": { + "kind": "User", + "name": "ImS8" + } + }, + "comments": { + "attached": "// 0 (1) // Rasterize at higher quality for sub-pixel positioning. 0 == auto == 1. This is not really useful as we don't use sub-pixel positions on the Y axis." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3613 + } + }, + { + "name": "EllipsisChar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "comments": { + "attached": "// 0 // Explicitly specify Unicode codepoint of ellipsis character. When fonts are being merged first specified ellipsis will be used." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3614 + } + }, + { + "name": "SizePixels", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// // Size in pixels for rasterizer (more or less maps to the resulting font height)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3615 + } + }, + { + "name": "GlyphRanges", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// NULL // *LEGACY* THE ARRAY DATA NEEDS TO PERSIST AS LONG AS THE FONT IS ALIVE. Pointer to a user-provided list of Unicode range (2 value per range, values are inclusive, zero-terminated list)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3616 + } + }, + { + "name": "GlyphExcludeRanges", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// NULL // Pointer to a small user-provided list of Unicode ranges (2 value per range, values are inclusive, zero-terminated list). This is very close to GlyphRanges[] but designed to exclude ranges from a font source, when merging fonts with overlapping glyphs. Use \"Input Glyphs Overlap Detection Tool\" to find about your overlapping ranges." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3617 + } + }, + { + "name": "GlyphOffset", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "preceding": [ + "//ImVec2 GlyphExtraSpacing; // 0, 0 // (REMOVED AT IT SEEMS LARGELY OBSOLETE. PLEASE REPORT IF YOU WERE USING THIS). Extra spacing (in pixels) between glyphs when rendered: essentially add to glyph->AdvanceX. Only X axis is supported for now." + ], + "attached": "// 0, 0 // Offset (in pixels) all glyphs from this font input. Absolute value for default size, other sizes will scale this value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3619 + } + }, + { + "name": "GlyphMinAdvanceX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 0 // Minimum AdvanceX for glyphs, set Min to align font icons, set both Min/Max to enforce mono-space font. Absolute value for default size, other sizes will scale this value." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3620 + } + }, + { + "name": "GlyphMaxAdvanceX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// FLT_MAX // Maximum AdvanceX for glyphs" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3621 + } + }, + { + "name": "GlyphExtraAdvanceX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 0 // Extra spacing (in pixels) between glyphs. Please contact us if you are using this. // FIXME-NEWATLAS: Intentionally unscaled" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3622 + } + }, + { + "name": "FontNo", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "comments": { + "attached": "// 0 // Index of font within TTF/OTF file" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3623 + } + }, + { + "name": "FontLoaderFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 0 // Settings for custom font builder. THIS IS BUILDER IMPLEMENTATION DEPENDENT. Leave as zero if unsure." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3624 + } + }, + { + "name": "RasterizerMultiply", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "//unsigned int FontBuilderFlags; // -- // [Renamed in 1.92] Ue FontLoaderFlags." + ], + "attached": "// 1.0f // Linearly brighten (>1.0f) or darken (<1.0f) font output. Brightening small fonts may be a good workaround to make them more readable. This is a silly thing we may remove in the future." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3626 + } + }, + { + "name": "RasterizerDensity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 1.0f // [LEGACY: this only makes sense when ImGuiBackendFlags_RendererHasTextures is not supported] DPI scale multiplier for rasterization. Not altering other font metrics: makes it easy to swap between e.g. a 100% and a 400% fonts for a zooming display, or handle Retina screen. IMPORTANT: If you change this it is expected that you increase/decrease font scale roughly to the inverse of this, otherwise quality may look lowered." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3627 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontFlags", + "description": { + "kind": "User", + "name": "ImFontFlags" + } + }, + "comments": { + "preceding": [ + "// [Internal]" + ], + "attached": "// Font flags (don't use just yet, will be exposed in upcoming 1.92.X updates)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3630 + } + }, + { + "name": "DstFont", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "comments": { + "attached": "// Target font (as we merging fonts, multiple ImFontConfig may target the same font)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3631 + } + }, + { + "name": "FontLoader", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const ImFontLoader*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontLoader", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Custom font backend for this source (default source is the one stored in ImFontAtlas)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3632 + } + }, + { + "name": "FontLoaderData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Font loader opaque storage (per font config)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3633 + } + } + ], + "comments": { + "preceding": [ + "// A font input/source (we may rename this to ImFontSource in the future)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3600 + } + }, + { + "name": "ImFontGlyph", + "original_fully_qualified_name": "ImFontGlyph", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Colored", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// Flag to indicate glyph is colored and should generally ignore tinting (make it usable with no shift on little-endian as this is used in loops)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3642 + } + }, + { + "name": "Visible", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// Flag to indicate glyph has no visible pixels (e.g. space). Allow early out when rendering." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3643 + } + }, + { + "name": "SourceIdx", + "is_array": false, + "width": 4, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// Index of source in parent font" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3644 + } + }, + { + "name": "Codepoint", + "is_array": false, + "width": 26, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 0x0000..0x10FFFF" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3645 + } + }, + { + "name": "AdvanceX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Horizontal distance to advance cursor/layout position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3646 + } + }, + { + "name": "X0", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Glyph corners. Offsets from current cursor/layout position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3647 + } + }, + { + "name": "Y0", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Glyph corners. Offsets from current cursor/layout position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3647 + } + }, + { + "name": "X1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Glyph corners. Offsets from current cursor/layout position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3647 + } + }, + { + "name": "Y1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Glyph corners. Offsets from current cursor/layout position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3647 + } + }, + { + "name": "U0", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Texture coordinates for the current value of ImFontAtlas->TexRef. Cached equivalent of calling GetCustomRect() with PackId." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3648 + } + }, + { + "name": "V0", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Texture coordinates for the current value of ImFontAtlas->TexRef. Cached equivalent of calling GetCustomRect() with PackId." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3648 + } + }, + { + "name": "U1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Texture coordinates for the current value of ImFontAtlas->TexRef. Cached equivalent of calling GetCustomRect() with PackId." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3648 + } + }, + { + "name": "V1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Texture coordinates for the current value of ImFontAtlas->TexRef. Cached equivalent of calling GetCustomRect() with PackId." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3648 + } + }, + { + "name": "PackId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// [Internal] ImFontAtlasRectId value (FIXME: Cold data, could be moved elsewhere?)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3649 + } + } + ], + "comments": { + "preceding": [ + "// Hold rendering data for one glyph.", + "// (Note: some language parsers may fail to convert the bitfield members, in this case maybe drop store a single u32 or we can rework this)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3640 + } + }, + { + "name": "ImFontGlyphRangesBuilder", + "original_fully_qualified_name": "ImFontGlyphRangesBuilder", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "UsedChars", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImU32", + "description": { + "kind": "User", + "name": "ImVector_ImU32" + } + }, + "comments": { + "attached": "// Store 1-bit per Unicode code point (0=unused, 1=used)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3658 + } + } + ], + "comments": { + "preceding": [ + "// Helper to build glyph ranges from text/string data. Feed your application strings/characters to it then call BuildRanges().", + "// This is essentially a tightly packed of vector of 64k booleans = 8KB storage." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3656 + } + }, + { + "name": "ImFontAtlasRect", + "original_fully_qualified_name": "ImFontAtlasRect", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "x", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Position (in current texture)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3680 + } + }, + { + "name": "y", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Position (in current texture)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3680 + } + }, + { + "name": "w", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3681 + } + }, + { + "name": "h", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned short", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_short" + } + }, + "comments": { + "attached": "// Size" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3681 + } + }, + { + "name": "uv0", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// UV coordinates (in current texture)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3682 + } + }, + { + "name": "uv1", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// UV coordinates (in current texture)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3682 + } + } + ], + "comments": { + "preceding": [ + "// Output of ImFontAtlas::GetCustomRect() when using custom rectangles.", + "// Those values may not be cached/stored as they are only valid for the current value of atlas->TexRef", + "// (this is in theory derived from ImTextureRect but we use separate structures for reasons)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3678 + } + }, + { + "name": "ImFontAtlas", + "original_fully_qualified_name": "ImFontAtlas", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlasFlags", + "description": { + "kind": "User", + "name": "ImFontAtlasFlags" + } + }, + "comments": { + "preceding": [ + "// Input" + ], + "attached": "// Build flags (see ImFontAtlasFlags_)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3804 + } + }, + { + "name": "TexDesiredFormat", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "comments": { + "attached": "// Desired texture format (default to ImTextureFormat_RGBA32 but may be changed to ImTextureFormat_Alpha8)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3805 + } + }, + { + "name": "TexGlyphPadding", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// FIXME: Should be called \"TexPackPadding\". Padding between glyphs within texture in pixels. Defaults to 1. If your rendering method doesn't rely on bilinear filtering you may set this to 0 (will also need to set AntiAliasedLinesUseTex = false)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3806 + } + }, + { + "name": "TexMinWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Minimum desired texture width. Must be a power of two. Default to 512." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3807 + } + }, + { + "name": "TexMinHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Minimum desired texture height. Must be a power of two. Default to 128." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3808 + } + }, + { + "name": "TexMaxWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Maximum desired texture width. Must be a power of two. Default to 8192." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3809 + } + }, + { + "name": "TexMaxHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Maximum desired texture height. Must be a power of two. Default to 8192." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3810 + } + }, + { + "name": "UserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Store your own atlas related user-data (if e.g. you have multiple font atlas)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3811 + } + }, + { + "name": "TexRef", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "comments": { + "attached": "// Latest texture identifier == TexData->GetTexRef()." + }, + "conditionals": [ + { + "condition": "ifdef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3817 + } + }, + { + "name": "__anonymous_type1", + "is_array": false, + "is_anonymous": true, + "type": { + "declaration": "__anonymous_type1", + "description": { + "kind": "User", + "name": "__anonymous_type1" + } + }, + "comments": { + "attached": "// Latest texture identifier == TexData->GetTexRef(). // RENAMED TexID to TexRef in 1.92.x" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "TexData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "comments": { + "attached": "// Latest texture." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3821 + } + }, + { + "name": "TexList", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImTextureDataPtr", + "description": { + "kind": "User", + "name": "ImVector_ImTextureDataPtr" + } + }, + "comments": { + "preceding": [ + "// [Internal]" + ], + "attached": "// Texture list (most often TexList.Size == 1). TexData is always == TexList.back(). DO NOT USE DIRECTLY, USE GetDrawData().Textures[]/GetPlatformIO().Textures[] instead!" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3824 + } + }, + { + "name": "Locked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Marked as locked during ImGui::NewFrame()..EndFrame() scope if TexUpdates are not supported. Any attempt to modify the atlas will assert." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3825 + } + }, + { + "name": "RendererHasTextures", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Copy of (BackendFlags & ImGuiBackendFlags_RendererHasTextures) from supporting context." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3826 + } + }, + { + "name": "TexIsBuilt", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Set when texture was built matching current font input. Mostly useful for legacy IsBuilt() call." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3827 + } + }, + { + "name": "TexPixelsUseColors", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Tell whether our texture data is known to use colors (rather than just alpha channel), in order to help backend select a format or conversion process." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3828 + } + }, + { + "name": "TexUvScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// = (1.0f/TexData->TexWidth, 1.0f/TexData->TexHeight). May change as new texture gets created." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3829 + } + }, + { + "name": "TexUvWhitePixel", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Texture coordinates to a white pixel. May change as new texture gets created." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3830 + } + }, + { + "name": "Fonts", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontPtr", + "description": { + "kind": "User", + "name": "ImVector_ImFontPtr" + } + }, + "comments": { + "attached": "// Hold all the fonts returned by AddFont*. Fonts[0] is the default font upon calling ImGui::NewFrame(), use ImGui::PushFont()/PopFont() to change the current font." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3831 + } + }, + { + "name": "Sources", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontConfig", + "description": { + "kind": "User", + "name": "ImVector_ImFontConfig" + } + }, + "comments": { + "attached": "// Source/configuration data" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3832 + } + }, + { + "name": "TexUvLines", + "is_array": true, + "array_bounds": "IM_DRAWLIST_TEX_LINES_WIDTH_MAX+1", + "is_anonymous": false, + "type": { + "declaration": "ImVec4[IM_DRAWLIST_TEX_LINES_WIDTH_MAX+1]", + "description": { + "kind": "Array", + "bounds": "IM_DRAWLIST_TEX_LINES_WIDTH_MAX+1", + "inner_type": { + "kind": "User", + "name": "ImVec4" + } + } + }, + "comments": { + "attached": "// UVs for baked anti-aliased lines" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3833 + } + }, + { + "name": "TexNextUniqueID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Next value to be stored in TexData->UniqueID" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3834 + } + }, + { + "name": "FontNextUniqueID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Next value to be stored in ImFont->FontID" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3835 + } + }, + { + "name": "DrawListSharedDatas", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImDrawListSharedDataPtr", + "description": { + "kind": "User", + "name": "ImVector_ImDrawListSharedDataPtr" + } + }, + "comments": { + "attached": "// List of users for this atlas. Typically one per Dear ImGui context." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3836 + } + }, + { + "name": "Builder", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlasBuilder*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasBuilder" + } + } + }, + "comments": { + "attached": "// Opaque interface to our data that doesn't need to be public and may be discarded when rebuilding." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3837 + } + }, + { + "name": "FontLoader", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const ImFontLoader*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontLoader", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Font loader opaque interface (default to use FreeType when IMGUI_ENABLE_FREETYPE is defined, otherwise default to use stb_truetype). Use SetFontLoader() to change this at runtime." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3838 + } + }, + { + "name": "FontLoaderName", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "comments": { + "attached": "// Font loader name (for display e.g. in About box) == FontLoader->Name" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3839 + } + }, + { + "name": "FontLoaderData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Font backend opaque storage" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3840 + } + }, + { + "name": "FontLoaderFlags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// Shared flags (for all fonts) for font loader. THIS IS BUILD IMPLEMENTATION DEPENDENT (e.g. Per-font override is also available in ImFontConfig)." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3841 + } + }, + { + "name": "RefCount", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// Number of contexts using this atlas" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3842 + } + }, + { + "name": "OwnerContext", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "comments": { + "attached": "// Context which own the atlas will be in charge of updating and destroying it." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3843 + } + }, + { + "name": "TempRect", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlasRect", + "description": { + "kind": "User", + "name": "ImFontAtlasRect" + } + }, + "comments": { + "preceding": [ + "// Legacy: You can request your rectangles to be mapped as font glyph (given a font + Unicode point), so you can render e.g. custom colorful icons and use them as regular glyphs. --> Prefer using a custom ImFontLoader." + ], + "attached": "// For old GetCustomRectByIndex() API" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3848 + } + } + ], + "comments": { + "preceding": [ + "// Load and rasterize multiple TTF/OTF fonts into a same texture. The font atlas will build a single texture holding:", + "// - One or more fonts.", + "// - Custom graphics data needed to render the shapes needed by Dear ImGui.", + "// - Mouse cursor shapes for software cursor rendering (unless setting 'Flags |= ImFontAtlasFlags_NoMouseCursors' in the font atlas).", + "// - If you don't call any AddFont*** functions, the default font embedded in the code will be loaded for you.", + "// It is the rendering backend responsibility to upload texture into your graphics API:", + "// - ImGui_ImplXXXX_RenderDrawData() functions generally iterate platform_io->Textures[] to create/update/destroy each ImTextureData instance.", + "// - Backend then set ImTextureData's TexID and BackendUserData.", + "// - Texture id are passed back to you during rendering to identify the texture. Read FAQ entry about ImTextureID/ImTextureRef for more details.", + "// Legacy path:", + "// - Call Build() + GetTexDataAsAlpha8() or GetTexDataAsRGBA32() to build and retrieve pixels data.", + "// - Call SetTexID(my_tex_id); and pass the pointer/identifier to your texture in a format natural to your graphics API.", + "// Common pitfalls:", + "// - If you pass a 'glyph_ranges' array to AddFont*** functions, you need to make sure that your array persist up until the", + "// atlas is build (when calling GetTexData*** or Build()). We only copy the pointer, not the data.", + "// - Important: By default, AddFontFromMemoryTTF() takes ownership of the data. Even though we are not writing to it, we will free the pointer on destruction.", + "// You can set font_cfg->FontDataOwnedByAtlas=false to keep ownership of your data and it won't be freed,", + "// - Even though many functions are suffixed with \"TTF\", OTF data is supported just as well.", + "// - This is an old API and it is currently awkward for those and various other reasons! We will address them in the future!" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3715 + } + }, + { + "name": "__anonymous_type1", + "original_fully_qualified_name": "ImFontAtlas::", + "kind": "union", + "by_value": false, + "forward_declaration": false, + "is_anonymous": true, + "fields": [ + { + "name": "TexRef", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3819 + } + }, + { + "name": "TexID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3819 + } + } + ], + "comments": { + "attached": "// Latest texture identifier == TexData->GetTexRef(). // RENAMED TexID to TexRef in 1.92.x" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3819 + } + }, + { + "name": "ImFontBaked", + "original_fully_qualified_name": "ImFontBaked", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "IndexAdvanceX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_float", + "description": { + "kind": "User", + "name": "ImVector_float" + } + }, + "comments": { + "preceding": [ + "// [Internal] Members: Hot ~20/24 bytes (for CalcTextSize)" + ], + "attached": "// 12-16 // out // Sparse. Glyphs->AdvanceX in a directly indexable way (cache-friendly for CalcTextSize functions which only this info, and are often bottleneck in large UI)." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3867 + } + }, + { + "name": "FallbackAdvanceX", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 4 // out // FindGlyph(FallbackChar)->AdvanceX" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3868 + } + }, + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 4 // in // Height of characters/line, set during loading (doesn't change after loading)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3869 + } + }, + { + "name": "RasterizerDensity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 4 // in // Density this is baked at" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3870 + } + }, + { + "name": "IndexLookup", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImU16", + "description": { + "kind": "User", + "name": "ImVector_ImU16" + } + }, + "comments": { + "preceding": [ + "// [Internal] Members: Hot ~28/36 bytes (for RenderText loop)" + ], + "attached": "// 12-16 // out // Sparse. Index glyphs by Unicode code-point." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3873 + } + }, + { + "name": "Glyphs", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontGlyph", + "description": { + "kind": "User", + "name": "ImVector_ImFontGlyph" + } + }, + "comments": { + "attached": "// 12-16 // out // All glyphs." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3874 + } + }, + { + "name": "FallbackGlyphIndex", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// 4 // out // Index of FontFallbackChar" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3875 + } + }, + { + "name": "Ascent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// [Internal] Members: Cold" + ], + "attached": "// 4+4 // out // Ascent: distance from top to bottom of e.g. 'A' [0..FontSize] (unscaled)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3878 + } + }, + { + "name": "Descent", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "preceding": [ + "// [Internal] Members: Cold" + ], + "attached": "// 4+4 // out // Ascent: distance from top to bottom of e.g. 'A' [0..FontSize] (unscaled)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3878 + } + }, + { + "name": "MetricsTotalSurface", + "is_array": false, + "width": 26, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 3 // out // Total surface in pixels to get an idea of the font rasterization/texture cost (not exact, we approximate the cost of padding between glyphs)" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3879 + } + }, + { + "name": "WantDestroy", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 0 // // Queued for destroy" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3880 + } + }, + { + "name": "LoadNoFallback", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 0 // // Disable loading fallback in lower-level calls." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3881 + } + }, + { + "name": "LoadNoRenderOnLayout", + "is_array": false, + "width": 1, + "is_anonymous": false, + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "comments": { + "attached": "// 0 // // Enable a two-steps mode where CalcTextSize() calls will load AdvanceX *without* rendering/packing glyphs. Only advantagous if you know that the glyph is unlikely to actually be rendered, otherwise it is slower because we'd do one query on the first CalcTextSize and one query on the first Draw." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3882 + } + }, + { + "name": "LastUsedFrame", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "attached": "// 4 // // Record of that time this was bounds" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3883 + } + }, + { + "name": "BakedId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// 4 // // Unique ID for this baked storage" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3884 + } + }, + { + "name": "ContainerFont", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "comments": { + "attached": "// 4-8 // in // Parent font" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3885 + } + }, + { + "name": "FontLoaderDatas", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// 4-8 // // Font loader opaque storage (per baked font * sources): single contiguous buffer allocated by imgui, passed to loader." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3886 + } + } + ], + "comments": { + "preceding": [ + "// Font runtime data for a given size", + "// Important: pointers to ImFontBaked are only valid for the current frame." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3864 + } + }, + { + "name": "ImFont", + "original_fully_qualified_name": "ImFont", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "LastBaked", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "comments": { + "preceding": [ + "// [Internal] Members: Hot ~12-20 bytes" + ], + "attached": "// 4-8 // Cache last bound baked. NEVER USE DIRECTLY. Use GetFontBaked()." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3915 + } + }, + { + "name": "ContainerAtlas", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "comments": { + "attached": "// 4-8 // What we have been loaded into." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3916 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImFontFlags", + "description": { + "kind": "User", + "name": "ImFontFlags" + } + }, + "comments": { + "attached": "// 4 // Font flags." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3917 + } + }, + { + "name": "CurrentRasterizerDensity", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Current rasterizer density. This is a varying state of the font." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3918 + } + }, + { + "name": "FontId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "preceding": [ + "// [Internal] Members: Cold ~24-52 bytes", + "// Conceptually Sources[] is the list of font sources merged to create this font." + ], + "attached": "// Unique identifier for the font" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3922 + } + }, + { + "name": "LegacySize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 4 // in // Font size passed to AddFont(). Use for old code calling PushFont() expecting to use that size. (use ImGui::GetFontBaked() to get font baked at current bound size)." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3923 + } + }, + { + "name": "Sources", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImFontConfigPtr", + "description": { + "kind": "User", + "name": "ImVector_ImFontConfigPtr" + } + }, + "comments": { + "attached": "// 16 // in // List of sources. Pointers within ContainerAtlas->Sources[]" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3924 + } + }, + { + "name": "EllipsisChar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "comments": { + "attached": "// 2-4 // out // Character used for ellipsis rendering ('...')." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3925 + } + }, + { + "name": "FallbackChar", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "comments": { + "attached": "// 2-4 // out // Character used if a glyph isn't found (U+FFFD, '?')" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3926 + } + }, + { + "name": "Used8kPagesMap", + "is_array": true, + "array_bounds": "(IM_UNICODE_CODEPOINT_MAX +1)/8192/8", + "is_anonymous": false, + "type": { + "declaration": "ImU8[(IM_UNICODE_CODEPOINT_MAX +1)/8192/8]", + "description": { + "kind": "Array", + "bounds": "(IM_UNICODE_CODEPOINT_MAX +1)/8192/8", + "inner_type": { + "kind": "User", + "name": "ImU8" + } + } + }, + "comments": { + "attached": "// 1 bytes if ImWchar=ImWchar16, 16 bytes if ImWchar==ImWchar32. Store 1-bit for each block of 4K codepoints that has one active glyph. This is mainly used to facilitate iterations across all used codepoints." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3927 + } + }, + { + "name": "EllipsisAutoBake", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// 1 // // Mark when the \"...\" glyph needs to be generated." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3928 + } + }, + { + "name": "RemapPairs", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiStorage", + "description": { + "kind": "User", + "name": "ImGuiStorage" + } + }, + "comments": { + "attached": "// 16 // // Remapping pairs when using AddRemapChar(), otherwise empty." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3929 + } + }, + { + "name": "Scale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 4 // in // Legacy base font scale (~1.0f), multiplied by the per-window font scale which you can adjust with SetWindowFontScale()" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3931 + } + } + ], + "comments": { + "preceding": [ + "// Font runtime data and rendering", + "// - ImFontAtlas automatically loads a default embedded font for you if you didn't load one manually.", + "// - Since 1.92.X a font may be rendered as any size! Therefore a font doesn't have one specific size.", + "// - Use 'font->GetFontBaked(size)' to retrieve the ImFontBaked* corresponding to a given size.", + "// - If you used g.Font + g.FontSize (which is frequent from the ImGui layer), you can use g.FontBaked as a shortcut, as g.FontBaked == g.Font->GetFontBaked(g.FontSize)." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3912 + } + }, + { + "name": "ImGuiViewport", + "original_fully_qualified_name": "ImGuiViewport", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "ID", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// Unique identifier for the viewport" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4012 + } + }, + { + "name": "Flags", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiViewportFlags", + "description": { + "kind": "User", + "name": "ImGuiViewportFlags" + } + }, + "comments": { + "attached": "// See ImGuiViewportFlags_" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4013 + } + }, + { + "name": "Pos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Main Area: Position of the viewport (Dear ImGui coordinates are the same as OS desktop/native coordinates)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4014 + } + }, + { + "name": "Size", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Main Area: Size of the viewport." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4015 + } + }, + { + "name": "FramebufferScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Density of the viewport for Retina display (always 1,1 on Windows, may be 2,2 etc on macOS/iOS). This will affect font rasterizer density." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4016 + } + }, + { + "name": "WorkPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Work Area: Position of the viewport minus task bars, menus bars, status bars (>= Pos)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4017 + } + }, + { + "name": "WorkSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Work Area: Size of the viewport minus task bars, menu bars, status bars (<= Size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4018 + } + }, + { + "name": "DpiScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 1.0f = 96 DPI = No extra scale." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4019 + } + }, + { + "name": "ParentViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// (Advanced) 0: no parent. Instruct the platform backend to setup a parent/child relationship between platform windows." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4020 + } + }, + { + "name": "DrawData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "comments": { + "attached": "// The ImDrawData corresponding to this viewport. Valid after Render() and until the next call to NewFrame()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4021 + } + }, + { + "name": "RendererUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "preceding": [ + "// Platform/Backend Dependent Data", + "// Our design separate the Renderer and Platform backends to facilitate combining default backends with each others.", + "// When our create your own backend for a custom engine, it is possible that both Renderer and Platform will be handled", + "// by the same system and you may not need to use all the UserData/Handle fields.", + "// The library never uses those fields, they are merely storage to facilitate backend implementation." + ], + "attached": "// void* to hold custom data structure for the renderer (e.g. swap chain, framebuffers etc.). generally set by your Renderer_CreateWindow function." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4028 + } + }, + { + "name": "PlatformUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// void* to hold custom data structure for the OS / platform (e.g. windowing info, render context). generally set by your Platform_CreateWindow function." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4029 + } + }, + { + "name": "PlatformHandle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// void* to hold higher-level, platform window handle (e.g. HWND for Win32 backend, Uint32 WindowID for SDL, GLFWWindow* for GLFW), for FindViewportByPlatformHandle()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4030 + } + }, + { + "name": "PlatformHandleRaw", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// void* to hold lower-level, platform-native window handle (always HWND on Win32 platform, unused for other platforms)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4031 + } + }, + { + "name": "PlatformWindowCreated", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window has been created (Platform_CreateWindow() has been called). This is false during the first frame where a viewport is being created." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4032 + } + }, + { + "name": "PlatformRequestMove", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window requested move (e.g. window was moved by the OS / host window manager, authoritative position will be OS window position)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4033 + } + }, + { + "name": "PlatformRequestResize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window requested resize (e.g. window was resized by the OS / host window manager, authoritative size will be OS window size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4034 + } + }, + { + "name": "PlatformRequestClose", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// Platform window requested closure (e.g. window was moved by the OS / host window manager, e.g. pressing ALT-F4)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4035 + } + } + ], + "comments": { + "preceding": [ + "// - Currently represents the Platform Window created by the application which is hosting our Dear ImGui windows.", + "// - With multi-viewport enabled, we extend this concept to have multiple active viewports.", + "// - In the future we will extend this concept further to also represent Platform Monitor and support a \"no main platform window\" operation mode.", + "// - About Main Area vs Work Area:", + "// - Main Area = entire viewport.", + "// - Work Area = entire viewport minus sections used by main menu bars (for platform windows), or by task bar (for platform monitor).", + "// - Windows are generally trying to stay within the Work Area of their host viewport." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4010 + } + }, + { + "name": "ImGuiPlatformIO", + "original_fully_qualified_name": "ImGuiPlatformIO", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "Platform_GetClipboardTextFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "const char* (*Platform_GetClipboardTextFn)(ImGuiContext* ctx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetClipboardTextFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Optional: Access OS clipboard", + "// (default to use native Win32 clipboard on Windows, otherwise uses a private clipboard. Override to access OS clipboard on other architectures)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_SetClipboardTextFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SetClipboardTextFn)(ImGuiContext* ctx, const char* text)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SetClipboardTextFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "text", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_ClipboardUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4108 + } + }, + { + "name": "Platform_OpenInShellFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*Platform_OpenInShellFn)(ImGuiContext* ctx, const char* path)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "path", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_OpenInShellFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "path", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Optional: Open link/folder/file in OS Shell", + "// (default to use ShellExecuteW() on Windows, system() on Linux/Mac)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_OpenInShellUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4113 + } + }, + { + "name": "Platform_SetImeDataFn", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SetImeDataFn)(ImGuiContext* ctx, ImGuiViewport* viewport, ImGuiPlatformImeData* data)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "ImGuiPlatformImeData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPlatformImeData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SetImeDataFn", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "ctx", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + { + "kind": "Type", + "name": "viewport", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPlatformImeData" + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Optional: Notify OS Input Method Editor of the screen position of your cursor for text input position (e.g. when using Japanese/Chinese IME on Windows)", + "// (default to use native imm32 api on Windows)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_ImeUserData", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4118 + } + }, + { + "name": "Platform_LocaleDecimalPoint", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "comments": { + "preceding": [ + "// Optional: Platform locale", + "// [Experimental] Configure decimal point e.g. '.' or ',' useful for some languages (e.g. German), generally pulled from *localeconv()->decimal_point" + ], + "attached": "// '.'" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4123 + } + }, + { + "name": "Renderer_TextureMaxWidth", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "comments": { + "preceding": [ + "// Optional: Maximum texture size supported by renderer (used to adjust how we size textures). 0 if not known." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4130 + } + }, + { + "name": "Renderer_TextureMaxHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4131 + } + }, + { + "name": "Renderer_RenderState", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "preceding": [ + "// Written by some backends during ImGui_ImplXXXX_RenderDrawData() call to point backend_specific ImGui_ImplXXXX_RenderState* structure." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4134 + } + }, + { + "name": "Platform_CreateWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_CreateWindow)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_CreateWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Platform Backend functions (e.g. Win32, GLFW, SDL) ------------------- Called by -----" + ], + "attached": "// . . U . . // Create a new platform window for the given viewport" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_DestroyWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_DestroyWindow)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_DestroyWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . U . D //" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_ShowWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_ShowWindow)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_ShowWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . // Newly created windows are initially hidden so SetWindowPos/Size/Title can be called on them before showing the window" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_SetWindowPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SetWindowPos)(ImGuiViewport* vp, ImVec2 pos)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SetWindowPos", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "pos", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . // Set platform window position (given the upper-left corner of client area)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_GetWindowPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2 (*Platform_GetWindowPos)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetWindowPos", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "User", + "name": "ImVec2" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . . . . // (Use ImGuiPlatformIO_SetPlatform_GetWindowPos() to set this from C, otherwise you will likely encounter stack corruption)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_SetWindowSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SetWindowSize)(ImGuiViewport* vp, ImVec2 size)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SetWindowSize", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "size", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . // Set platform window client area size (ignoring OS decorations such as OS title bar etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_GetWindowSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2 (*Platform_GetWindowSize)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetWindowSize", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "User", + "name": "ImVec2" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . . . . // Get platform window client area size (Use ImGuiPlatformIO_SetPlatform_GetWindowSize() to set this from C, otherwise you will likely encounter stack corruption)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_GetWindowFramebufferScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2 (*Platform_GetWindowFramebufferScale)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetWindowFramebufferScale", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "User", + "name": "ImVec2" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . . . . // Return viewport density. Always 1,1 on Windows, often 2,2 on Retina display on macOS/iOS. MUST BE INTEGER VALUES. (Use ImGuiPlatformIO_SetPlatform_GetWindowFramebufferScale() to set this from C, otherwise you will likely encounter stack corruption)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_SetWindowFocus", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SetWindowFocus)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SetWindowFocus", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . . . . // Move window to front and set input focus" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_GetWindowFocus", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*Platform_GetWindowFocus)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetWindowFocus", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . //" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_GetWindowMinimized", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool (*Platform_GetWindowMinimized)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetWindowMinimized", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . . . . // Get platform window minimized state. When minimized, we generally won't attempt to get/set size and contents will be culled more easily" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_SetWindowTitle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SetWindowTitle)(ImGuiViewport* vp, const char* str)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SetWindowTitle", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "str", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . // Set platform window title (given an UTF-8 string)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_SetWindowAlpha", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SetWindowAlpha)(ImGuiViewport* vp, float alpha)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "alpha", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SetWindowAlpha", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "alpha", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . // (Optional) Setup global transparency (not per-pixel transparency)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_UpdateWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_UpdateWindow)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_UpdateWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . // (Optional) Called by UpdatePlatformWindows(). Optional hook to allow the platform backend from doing general book-keeping every frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_RenderWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_RenderWindow)(ImGuiViewport* vp, void* render_arg)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "render_arg", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_RenderWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "render_arg", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . . R . // (Optional) Main rendering (platform side! This is often unused, or just setting a \"current\" context for OpenGL bindings). 'render_arg' is the value passed to RenderPlatformWindowsDefault()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_SwapBuffers", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_SwapBuffers)(ImGuiViewport* vp, void* render_arg)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "render_arg", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_SwapBuffers", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "render_arg", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . . R . // (Optional) Call Present/SwapBuffers (platform side! This is often unused!). 'render_arg' is the value passed to RenderPlatformWindowsDefault()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_GetWindowDpiScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float (*Platform_GetWindowDpiScale)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetWindowDpiScale", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "float" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . . . . // (Optional) [BETA] FIXME-DPI: DPI handling: Return DPI scale for this viewport. 1.0f = 96 DPI." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_OnChangedViewport", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Platform_OnChangedViewport)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_OnChangedViewport", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . F . . . // (Optional) [BETA] FIXME-DPI: DPI handling: Called during Begin() every time the viewport we are outputting into changes, so backend has a chance to swap fonts to adjust style." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_GetWindowWorkAreaInsets", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec4 (*Platform_GetWindowWorkAreaInsets)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_GetWindowWorkAreaInsets", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "User", + "name": "ImVec4" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . . . . // (Optional) [BETA] Get initial work area inset for the viewport (won't be covered by main menu bar, dockspace over viewport etc.). Default to (0,0),(0,0). 'safeAreaInsets' in iOS land, 'DisplayCutout' in Android land. (Use ImGuiPlatformIO_SetPlatform_GetWindowWorkAreaInsets() to set this from C, otherwise you will likely encounter stack corruption)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Platform_CreateVkSurface", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "int (*Platform_CreateVkSurface)(ImGuiViewport* vp, ImU64 vk_inst, const void* vk_allocators, ImU64* out_vk_surface)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vk_inst", + "type": { + "declaration": "ImU64", + "description": { + "kind": "User", + "name": "ImU64" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vk_allocators", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_vk_surface", + "type": { + "declaration": "ImU64*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU64" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Platform_CreateVkSurface", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "int" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "vk_inst", + "inner_type": { + "kind": "User", + "name": "ImU64" + } + }, + { + "kind": "Type", + "name": "vk_allocators", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + { + "kind": "Type", + "name": "out_vk_surface", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImU64" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// (Optional) For a Vulkan Renderer to call into Platform code (since the surface creation needs to tie them both)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Renderer_CreateWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Renderer_CreateWindow)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Renderer_CreateWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "preceding": [ + "// Renderer Backend functions (e.g. DirectX, OpenGL, Vulkan) ------------ Called by -----" + ], + "attached": "// . . U . . // Create swap chain, frame buffers etc. (called after Platform_CreateWindow)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Renderer_DestroyWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Renderer_DestroyWindow)(ImGuiViewport* vp)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Renderer_DestroyWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// N . U . D // Destroy swap chain, frame buffers etc. (called before Platform_DestroyWindow)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Renderer_SetWindowSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Renderer_SetWindowSize)(ImGuiViewport* vp, ImVec2 size)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Renderer_SetWindowSize", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "size", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . U . . // Resize swap chain, frame buffers etc. (called after Platform_SetWindowSize)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Renderer_RenderWindow", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Renderer_RenderWindow)(ImGuiViewport* vp, void* render_arg)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "render_arg", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Renderer_RenderWindow", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "render_arg", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . . R . // (Optional) Clear framebuffer, setup render target, then render the viewport->DrawData. 'render_arg' is the value passed to RenderPlatformWindowsDefault()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Renderer_SwapBuffers", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void (*Renderer_SwapBuffers)(ImGuiViewport* vp, void* render_arg)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "render_arg", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "Renderer_SwapBuffers", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "render_arg", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + ] + } + } + } + }, + "comments": { + "attached": "// . . . R . // (Optional) Call Present/SwapBuffers. 'render_arg' is the value passed to RenderPlatformWindowsDefault()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h" + } + }, + { + "name": "Monitors", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiPlatformMonitor", + "description": { + "kind": "User", + "name": "ImVector_ImGuiPlatformMonitor" + } + }, + "comments": { + "preceding": [ + "// (Optional) Monitor list", + "// - Updated by: app/backend. Update every frame to dynamically support changing monitor or DPI configuration.", + "// - Used by: dear imgui to query DPI info, clamp popups/tooltips within same monitor and not have them straddle monitors." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4184 + } + }, + { + "name": "Textures", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImTextureDataPtr", + "description": { + "kind": "User", + "name": "ImVector_ImTextureDataPtr" + } + }, + "comments": { + "preceding": [ + "// Textures list (the list is updated by calling ImGui::EndFrame or ImGui::Render)", + "// The ImGui_ImplXXXX_RenderDrawData() function of each backend generally access this via ImDrawData::Textures which points to this. The array is available here mostly because backends will want to destroy textures on shutdown." + ], + "attached": "// List of textures used by Dear ImGui (most often 1) + contents of external texture list is automatically appended into this." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4192 + } + }, + { + "name": "Viewports", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVector_ImGuiViewportPtr", + "description": { + "kind": "User", + "name": "ImVector_ImGuiViewportPtr" + } + }, + "comments": { + "preceding": [ + "// Viewports list (the list is updated by calling ImGui::EndFrame or ImGui::Render)", + "// (in the future we will attempt to organize this feature to remove the need for a \"main viewport\")" + ], + "attached": "// Main viewports, followed by all secondary viewports." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4196 + } + } + ], + "comments": { + "preceding": [ + "// Access via ImGui::GetPlatformIO()" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4096 + } + }, + { + "name": "ImGuiPlatformMonitor", + "original_fully_qualified_name": "ImGuiPlatformMonitor", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "MainPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Coordinates of the area displayed on this monitor (Min = upper left, Max = bottom right)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4203 + } + }, + { + "name": "MainSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Coordinates of the area displayed on this monitor (Min = upper left, Max = bottom right)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4203 + } + }, + { + "name": "WorkPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Coordinates without task bars / side bars / menu bars. Used to avoid positioning popups/tooltips inside this region. If you don't have this info, please copy the value for MainPos/MainSize." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4204 + } + }, + { + "name": "WorkSize", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Coordinates without task bars / side bars / menu bars. Used to avoid positioning popups/tooltips inside this region. If you don't have this info, please copy the value for MainPos/MainSize." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4204 + } + }, + { + "name": "DpiScale", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// 1.0f = 96 DPI" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4205 + } + }, + { + "name": "PlatformHandle", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "comments": { + "attached": "// Backend dependant data (e.g. HMONITOR, GLFWmonitor*, SDL Display Index, NSScreen*)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4206 + } + } + ], + "comments": { + "preceding": [ + "// (Optional) This is required when enabling multi-viewport. Represent the bounds of each connected monitor/display and their DPI.", + "// We use this information for multiple DPI support + clamping the position of popups and tooltips so they don't straddle multiple monitors." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4201 + } + }, + { + "name": "ImGuiPlatformImeData", + "original_fully_qualified_name": "ImGuiPlatformImeData", + "kind": "struct", + "by_value": false, + "forward_declaration": false, + "is_anonymous": false, + "fields": [ + { + "name": "WantVisible", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// A widget wants the IME to be visible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4213 + } + }, + { + "name": "WantTextInput", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "comments": { + "attached": "// A widget wants text input, not necessarily IME to be visible. This is automatically set to the upcoming value of io.WantTextInput." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4214 + } + }, + { + "name": "InputPos", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "comments": { + "attached": "// Position of input cursor (for IME)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4215 + } + }, + { + "name": "InputLineHeight", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "comments": { + "attached": "// Line height (for IME)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4216 + } + }, + { + "name": "ViewportId", + "is_array": false, + "is_anonymous": false, + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "comments": { + "attached": "// ID of platform window/viewport." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4217 + } + } + ], + "comments": { + "preceding": [ + "// (Optional) Support for IME (Input Method Editor) via the platform_io.Platform_SetImeDataFn() function. Handler is called during EndFrame()." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4211 + } + } + ], + "functions": [ + { + "name": "ImTextureRef_GetTexID", + "original_fully_qualified_name": "GetTexID", + "return_type": { + "declaration": "ImTextureID", + "description": { + "kind": "User", + "name": "ImTextureID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImTextureRef*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureRef", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureRef", + "comments": { + "attached": "// == (_TexData ? _TexData->TexID : _TexID) // Implemented below in the file." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 370 + } + }, + { + "name": "ImGui_CreateContext", + "original_fully_qualified_name": "ImGui::CreateContext", + "return_type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "arguments": [ + { + "name": "shared_font_atlas", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Context creation and access", + "// - Each context create its own ImFontAtlas by default. You may instance one yourself and pass it to CreateContext() to share a font atlas between contexts.", + "// - DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()", + "// for each static/DLL boundary you are calling from. Read \"Context and Memory Allocators\" section of imgui.cpp for details." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 389 + } + }, + { + "name": "ImGui_DestroyContext", + "original_fully_qualified_name": "ImGui::DestroyContext", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// NULL = destroy current context" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 390 + } + }, + { + "name": "ImGui_GetCurrentContext", + "original_fully_qualified_name": "ImGui::GetCurrentContext", + "return_type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 391 + } + }, + { + "name": "ImGui_SetCurrentContext", + "original_fully_qualified_name": "ImGui::SetCurrentContext", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ctx", + "type": { + "declaration": "ImGuiContext*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiContext" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 392 + } + }, + { + "name": "ImGui_GetIO", + "original_fully_qualified_name": "ImGui::GetIO", + "return_type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Main" + ], + "attached": "// access the ImGuiIO structure (mouse/keyboard/gamepad inputs, time, various configuration options/flags)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 395 + } + }, + { + "name": "ImGui_GetPlatformIO", + "original_fully_qualified_name": "ImGui::GetPlatformIO", + "return_type": { + "declaration": "ImGuiPlatformIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "User", + "name": "ImGuiPlatformIO" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// access the ImGuiPlatformIO structure (mostly hooks/functions to connect to platform/renderer and OS Clipboard, IME etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 396 + } + }, + { + "name": "ImGui_GetStyle", + "original_fully_qualified_name": "ImGui::GetStyle", + "return_type": { + "declaration": "ImGuiStyle*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "User", + "name": "ImGuiStyle" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// access the Style structure (colors, sizes). Always use PushStyleColor(), PushStyleVar() to modify style mid-frame!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 397 + } + }, + { + "name": "ImGui_NewFrame", + "original_fully_qualified_name": "ImGui::NewFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// start a new Dear ImGui frame, you can submit any command from this point until Render()/EndFrame()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 398 + } + }, + { + "name": "ImGui_EndFrame", + "original_fully_qualified_name": "ImGui::EndFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ends the Dear ImGui frame. automatically called by Render(). If you don't need to render data (skipping rendering) you may call EndFrame() without Render()... but you'll have wasted CPU already! If you don't need to render, better to not create any windows and not call NewFrame() at all!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 399 + } + }, + { + "name": "ImGui_Render", + "original_fully_qualified_name": "ImGui::Render", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ends the Dear ImGui frame, finalize the draw data. You can then get call GetDrawData()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 400 + } + }, + { + "name": "ImGui_GetDrawData", + "original_fully_qualified_name": "ImGui::GetDrawData", + "return_type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// valid after Render() and until the next call to NewFrame(). Call ImGui_ImplXXXX_RenderDrawData() function in your Renderer Backend to render." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 401 + } + }, + { + "name": "ImGui_ShowDemoWindow", + "original_fully_qualified_name": "ImGui::ShowDemoWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Demo, Debug, Information" + ], + "attached": "// create Demo window. demonstrate most ImGui features. call this to learn about the library! try to make it always available in your application!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 404 + } + }, + { + "name": "ImGui_ShowMetricsWindow", + "original_fully_qualified_name": "ImGui::ShowMetricsWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create Metrics/Debugger window. display Dear ImGui internals: windows, draw commands, various internal state, etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 405 + } + }, + { + "name": "ImGui_ShowDebugLogWindow", + "original_fully_qualified_name": "ImGui::ShowDebugLogWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create Debug Log window. display a simplified log of important dear imgui events." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 406 + } + }, + { + "name": "ImGui_ShowIDStackToolWindow", + "original_fully_qualified_name": "ImGui::ShowIDStackToolWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied p_open = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 407 + } + }, + { + "name": "ImGui_ShowIDStackToolWindowEx", + "original_fully_qualified_name": "ImGui::ShowIDStackToolWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create Stack Tool window. hover items with mouse to query information about the source of their unique ID." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 407 + } + }, + { + "name": "ImGui_ShowAboutWindow", + "original_fully_qualified_name": "ImGui::ShowAboutWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create About window. display Dear ImGui version, credits and build/system information." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 408 + } + }, + { + "name": "ImGui_ShowStyleEditor", + "original_fully_qualified_name": "ImGui::ShowStyleEditor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ref", + "type": { + "declaration": "ImGuiStyle*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStyle" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// add style editor block (not a window). you can pass in a reference ImGuiStyle structure to compare to, revert to and save to (else it uses the default style)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 409 + } + }, + { + "name": "ImGui_ShowStyleSelector", + "original_fully_qualified_name": "ImGui::ShowStyleSelector", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// add style selector block (not a window), essentially a combo listing the default styles." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 410 + } + }, + { + "name": "ImGui_ShowFontSelector", + "original_fully_qualified_name": "ImGui::ShowFontSelector", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// add font selector block (not a window), essentially a combo listing the loaded fonts." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 411 + } + }, + { + "name": "ImGui_ShowUserGuide", + "original_fully_qualified_name": "ImGui::ShowUserGuide", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// add basic help/info block (not a window): how to manipulate ImGui as an end-user (mouse/keyboard controls)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 412 + } + }, + { + "name": "ImGui_GetVersion", + "original_fully_qualified_name": "ImGui::GetVersion", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get the compiled version string e.g. \"1.80 WIP\" (essentially the value for IMGUI_VERSION from the compiled version of imgui.cpp)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 413 + } + }, + { + "name": "ImGui_StyleColorsDark", + "original_fully_qualified_name": "ImGui::StyleColorsDark", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "dst", + "type": { + "declaration": "ImGuiStyle*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStyle" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Styles" + ], + "attached": "// new, recommended style (default)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 416 + } + }, + { + "name": "ImGui_StyleColorsLight", + "original_fully_qualified_name": "ImGui::StyleColorsLight", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "dst", + "type": { + "declaration": "ImGuiStyle*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStyle" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// best used with borders and a custom, thicker font" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 417 + } + }, + { + "name": "ImGui_StyleColorsClassic", + "original_fully_qualified_name": "ImGui::StyleColorsClassic", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "dst", + "type": { + "declaration": "ImGuiStyle*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStyle" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// classic imgui style" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 418 + } + }, + { + "name": "ImGui_Begin", + "original_fully_qualified_name": "ImGui::Begin", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Windows", + "// - Begin() = push window to the stack and start appending to it. End() = pop window from the stack.", + "// - Passing 'bool* p_open != NULL' shows a window-closing widget in the upper-right corner of the window,", + "// which clicking will set the boolean to false when clicked.", + "// - You may append multiple times to the same window during the same frame by calling Begin()/End() pairs multiple times.", + "// Some information such as 'flags' or 'p_open' will only be considered by the first call to Begin().", + "// - Begin() return false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting", + "// anything to the window. Always call a matching End() for each Begin() call, regardless of its return value!", + "// [Important: due to legacy reason, Begin/End and BeginChild/EndChild are inconsistent with all other functions", + "// such as BeginMenu/EndMenu, BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding", + "// BeginXXX function returned true. Begin and BeginChild are the only odd ones out. Will be fixed in a future update.]", + "// - Note that the bottom of window stack always contains a window called \"Debug\"." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 432 + } + }, + { + "name": "ImGui_End", + "original_fully_qualified_name": "ImGui::End", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 433 + } + }, + { + "name": "ImGui_BeginChild", + "original_fully_qualified_name": "ImGui::BeginChild", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "child_flags", + "type": { + "declaration": "ImGuiChildFlags", + "description": { + "kind": "User", + "name": "ImGuiChildFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Child Windows", + "// - Use child windows to begin into a self-contained independent scrolling/clipping regions within a host window. Child windows can embed their own child.", + "// - Before 1.90 (November 2023), the \"ImGuiChildFlags child_flags = 0\" parameter was \"bool border = false\".", + "// This API is backward compatible with old code, as we guarantee that ImGuiChildFlags_Borders == true.", + "// Consider updating your old code:", + "// BeginChild(\"Name\", size, false) -> Begin(\"Name\", size, 0); or Begin(\"Name\", size, ImGuiChildFlags_None);", + "// BeginChild(\"Name\", size, true) -> Begin(\"Name\", size, ImGuiChildFlags_Borders);", + "// - Manual sizing (each axis can use a different setting e.g. ImVec2(0.0f, 400.0f)):", + "// == 0.0f: use remaining parent window size for this axis.", + "// > 0.0f: use specified size for this axis.", + "// < 0.0f: right/bottom-align to specified distance from available content boundaries.", + "// - Specifying ImGuiChildFlags_AutoResizeX or ImGuiChildFlags_AutoResizeY makes the sizing automatic based on child contents.", + "// Combining both ImGuiChildFlags_AutoResizeX _and_ ImGuiChildFlags_AutoResizeY defeats purpose of a scrolling region and is NOT recommended.", + "// - BeginChild() returns false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting", + "// anything to the window. Always call a matching EndChild() for each BeginChild() call, regardless of its return value.", + "// [Important: due to legacy reason, Begin/End and BeginChild/EndChild are inconsistent with all other functions", + "// such as BeginMenu/EndMenu, BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding", + "// BeginXXX function returned true. Begin and BeginChild are the only odd ones out. Will be fixed in a future update.]" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 453 + } + }, + { + "name": "ImGui_BeginChildID", + "original_fully_qualified_name": "ImGui::BeginChild", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "child_flags", + "type": { + "declaration": "ImGuiChildFlags", + "description": { + "kind": "User", + "name": "ImGuiChildFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 454 + } + }, + { + "name": "ImGui_EndChild", + "original_fully_qualified_name": "ImGui::EndChild", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 455 + } + }, + { + "name": "ImGui_IsWindowAppearing", + "original_fully_qualified_name": "ImGui::IsWindowAppearing", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Windows Utilities", + "// - 'current window' = the window we are appending into while inside a Begin()/End() block. 'next window' = next window we will Begin() into." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 459 + } + }, + { + "name": "ImGui_IsWindowCollapsed", + "original_fully_qualified_name": "ImGui::IsWindowCollapsed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 460 + } + }, + { + "name": "ImGui_IsWindowFocused", + "original_fully_qualified_name": "ImGui::IsWindowFocused", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiFocusedFlags", + "description": { + "kind": "User", + "name": "ImGuiFocusedFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is current window focused? or its root/child, depending on flags. see flags for options." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 461 + } + }, + { + "name": "ImGui_IsWindowHovered", + "original_fully_qualified_name": "ImGui::IsWindowHovered", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiHoveredFlags", + "description": { + "kind": "User", + "name": "ImGuiHoveredFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is current window hovered and hoverable (e.g. not blocked by a popup/modal)? See ImGuiHoveredFlags_ for options. IMPORTANT: If you are trying to check whether your mouse should be dispatched to Dear ImGui or to your underlying app, you should not use this function! Use the 'io.WantCaptureMouse' boolean for that! Refer to FAQ entry \"How can I tell whether to dispatch mouse/keyboard to Dear ImGui or my application?\" for details." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 462 + } + }, + { + "name": "ImGui_GetWindowDrawList", + "original_fully_qualified_name": "ImGui::GetWindowDrawList", + "return_type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get draw list associated to the current window, to append your own drawing primitives" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 463 + } + }, + { + "name": "ImGui_GetWindowDpiScale", + "original_fully_qualified_name": "ImGui::GetWindowDpiScale", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get DPI scale currently associated to the current window's viewport." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 464 + } + }, + { + "name": "ImGui_GetWindowPos", + "original_fully_qualified_name": "ImGui::GetWindowPos", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current window position in screen space (IT IS UNLIKELY YOU EVER NEED TO USE THIS. Consider always using GetCursorScreenPos() and GetContentRegionAvail() instead)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 465 + } + }, + { + "name": "ImGui_GetWindowSize", + "original_fully_qualified_name": "ImGui::GetWindowSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current window size (IT IS UNLIKELY YOU EVER NEED TO USE THIS. Consider always using GetCursorScreenPos() and GetContentRegionAvail() instead)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 466 + } + }, + { + "name": "ImGui_GetWindowWidth", + "original_fully_qualified_name": "ImGui::GetWindowWidth", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current window width (IT IS UNLIKELY YOU EVER NEED TO USE THIS). Shortcut for GetWindowSize().x." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 467 + } + }, + { + "name": "ImGui_GetWindowHeight", + "original_fully_qualified_name": "ImGui::GetWindowHeight", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current window height (IT IS UNLIKELY YOU EVER NEED TO USE THIS). Shortcut for GetWindowSize().y." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 468 + } + }, + { + "name": "ImGui_GetWindowViewport", + "original_fully_qualified_name": "ImGui::GetWindowViewport", + "return_type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get viewport currently associated to the current window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 469 + } + }, + { + "name": "ImGui_SetNextWindowPos", + "original_fully_qualified_name": "ImGui::SetNextWindowPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Window manipulation", + "// - Prefer using SetNextXXX functions (before Begin) rather that SetXXX functions (after Begin)." + ], + "attached": "// Implied pivot = ImVec2(0, 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 473 + } + }, + { + "name": "ImGui_SetNextWindowPosEx", + "original_fully_qualified_name": "ImGui::SetNextWindowPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "pivot", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 473 + } + }, + { + "name": "ImGui_SetNextWindowSize", + "original_fully_qualified_name": "ImGui::SetNextWindowSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 474 + } + }, + { + "name": "ImGui_SetNextWindowSizeConstraints", + "original_fully_qualified_name": "ImGui::SetNextWindowSizeConstraints", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "size_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "custom_callback", + "type": { + "declaration": "ImGuiSizeCallback", + "description": { + "kind": "User", + "name": "ImGuiSizeCallback" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "custom_callback_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window size limits. use 0.0f or FLT_MAX if you don't want limits. Use -1 for both min and max of same axis to preserve current size (which itself is a constraint). Use callback to apply non-trivial programmatic constraints." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 475 + } + }, + { + "name": "ImGui_SetNextWindowContentSize", + "original_fully_qualified_name": "ImGui::SetNextWindowContentSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window content size (~ scrollable client area, which enforce the range of scrollbars). Not including window decorations (title bar, menu bar, etc.) nor WindowPadding. set an axis to 0.0f to leave it automatic. call before Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 476 + } + }, + { + "name": "ImGui_SetNextWindowCollapsed", + "original_fully_qualified_name": "ImGui::SetNextWindowCollapsed", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "collapsed", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window collapsed state. call before Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 477 + } + }, + { + "name": "ImGui_SetNextWindowFocus", + "original_fully_qualified_name": "ImGui::SetNextWindowFocus", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window to be focused / top-most. call before Begin()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 478 + } + }, + { + "name": "ImGui_SetNextWindowScroll", + "original_fully_qualified_name": "ImGui::SetNextWindowScroll", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "scroll", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window scrolling value (use < 0.0f to not affect a given axis)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 479 + } + }, + { + "name": "ImGui_SetNextWindowBgAlpha", + "original_fully_qualified_name": "ImGui::SetNextWindowBgAlpha", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "alpha", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window background color alpha. helper to easily override the Alpha component of ImGuiCol_WindowBg/ChildBg/PopupBg. you may also use ImGuiWindowFlags_NoBackground." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 480 + } + }, + { + "name": "ImGui_SetNextWindowViewport", + "original_fully_qualified_name": "ImGui::SetNextWindowViewport", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "viewport_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window viewport" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 481 + } + }, + { + "name": "ImGui_SetWindowPos", + "original_fully_qualified_name": "ImGui::SetWindowPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// (not recommended) set current window position - call within Begin()/End(). prefer using SetNextWindowPos(), as this may incur tearing and side-effects." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 482 + } + }, + { + "name": "ImGui_SetWindowSize", + "original_fully_qualified_name": "ImGui::SetWindowSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// (not recommended) set current window size - call within Begin()/End(). set to ImVec2(0, 0) to force an auto-fit. prefer using SetNextWindowSize(), as this may incur tearing and minor side-effects." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 483 + } + }, + { + "name": "ImGui_SetWindowCollapsed", + "original_fully_qualified_name": "ImGui::SetWindowCollapsed", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "collapsed", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 484 + } + }, + { + "name": "ImGui_SetWindowFocus", + "original_fully_qualified_name": "ImGui::SetWindowFocus", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// (not recommended) set current window to be focused / top-most. prefer using SetNextWindowFocus()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 485 + } + }, + { + "name": "ImGui_SetWindowPosStr", + "original_fully_qualified_name": "ImGui::SetWindowPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set named window position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 486 + } + }, + { + "name": "ImGui_SetWindowSizeStr", + "original_fully_qualified_name": "ImGui::SetWindowSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set named window size. set axis to 0.0f to force an auto-fit on this axis." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 487 + } + }, + { + "name": "ImGui_SetWindowCollapsedStr", + "original_fully_qualified_name": "ImGui::SetWindowCollapsed", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "collapsed", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set named window collapsed state" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 488 + } + }, + { + "name": "ImGui_SetWindowFocusStr", + "original_fully_qualified_name": "ImGui::SetWindowFocus", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set named window to be focused / top-most. use NULL to remove focus." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 489 + } + }, + { + "name": "ImGui_GetScrollX", + "original_fully_qualified_name": "ImGui::GetScrollX", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Windows Scrolling", + "// - Any change of Scroll will be applied at the beginning of next frame in the first call to Begin().", + "// - You may instead use SetNextWindowScroll() prior to calling Begin() to avoid this delay, as an alternative to using SetScrollX()/SetScrollY()." + ], + "attached": "// get scrolling amount [0 .. GetScrollMaxX()]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 494 + } + }, + { + "name": "ImGui_GetScrollY", + "original_fully_qualified_name": "ImGui::GetScrollY", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get scrolling amount [0 .. GetScrollMaxY()]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 495 + } + }, + { + "name": "ImGui_SetScrollX", + "original_fully_qualified_name": "ImGui::SetScrollX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "scroll_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set scrolling amount [0 .. GetScrollMaxX()]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 496 + } + }, + { + "name": "ImGui_SetScrollY", + "original_fully_qualified_name": "ImGui::SetScrollY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "scroll_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set scrolling amount [0 .. GetScrollMaxY()]" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 497 + } + }, + { + "name": "ImGui_GetScrollMaxX", + "original_fully_qualified_name": "ImGui::GetScrollMaxX", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get maximum scrolling amount ~~ ContentSize.x - WindowSize.x - DecorationsSize.x" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 498 + } + }, + { + "name": "ImGui_GetScrollMaxY", + "original_fully_qualified_name": "ImGui::GetScrollMaxY", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get maximum scrolling amount ~~ ContentSize.y - WindowSize.y - DecorationsSize.y" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 499 + } + }, + { + "name": "ImGui_SetScrollHereX", + "original_fully_qualified_name": "ImGui::SetScrollHereX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "center_x_ratio", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.5f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// adjust scrolling amount to make current cursor position visible. center_x_ratio=0.0: left, 0.5: center, 1.0: right. When using to make a \"default/current item\" visible, consider using SetItemDefaultFocus() instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 500 + } + }, + { + "name": "ImGui_SetScrollHereY", + "original_fully_qualified_name": "ImGui::SetScrollHereY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "center_y_ratio", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.5f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom. When using to make a \"default/current item\" visible, consider using SetItemDefaultFocus() instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 501 + } + }, + { + "name": "ImGui_SetScrollFromPosX", + "original_fully_qualified_name": "ImGui::SetScrollFromPosX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "local_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "center_x_ratio", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.5f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 502 + } + }, + { + "name": "ImGui_SetScrollFromPosY", + "original_fully_qualified_name": "ImGui::SetScrollFromPosY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "local_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "center_y_ratio", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.5f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 503 + } + }, + { + "name": "ImGui_PushFontFloat", + "original_fully_qualified_name": "ImGui::PushFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size_base_unscaled", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Parameters stacks (font)", + "// - PushFont(font, 0.0f) // Change font and keep current size", + "// - PushFont(NULL, 20.0f) // Keep font and change current size", + "// - PushFont(font, 20.0f) // Change font and set size to 20.0f", + "// - PushFont(font, style.FontSizeBase * 2.0f) // Change font and set size to be twice bigger than current size.", + "// - PushFont(font, font->LegacySize) // Change font and set size to size passed to AddFontXXX() function. Same as pre-1.92 behavior.", + "// *IMPORTANT* before 1.92, fonts had a single size. They can now be dynamically be adjusted.", + "// - In 1.92 we have REMOVED the single parameter version of PushFont() because it seems like the easiest way to provide an error-proof transition.", + "// - PushFont(font) before 1.92 = PushFont(font, font->LegacySize) after 1.92 // Use default font size as passed to AddFontXXX() function.", + "// *IMPORTANT* global scale factors are applied over the provided size.", + "// - Global scale factors are: 'style.FontScaleMain', 'style.FontScaleDpi' and maybe more.", + "// - If you want to apply a factor to the _current_ font size:", + "// - CORRECT: PushFont(NULL, style.FontSizeBase) // use current unscaled size == does nothing", + "// - CORRECT: PushFont(NULL, style.FontSizeBase * 2.0f) // use current unscaled size x2 == make text twice bigger", + "// - INCORRECT: PushFont(NULL, GetFontSize()) // INCORRECT! using size after global factors already applied == GLOBAL SCALING FACTORS WILL APPLY TWICE!", + "// - INCORRECT: PushFont(NULL, GetFontSize() * 2.0f) // INCORRECT! using size after global factors already applied == GLOBAL SCALING FACTORS WILL APPLY TWICE!" + ], + "attached": "// Use NULL as a shortcut to keep current font. Use 0.0f to keep current size." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 521 + } + }, + { + "name": "ImGui_PopFont", + "original_fully_qualified_name": "ImGui::PopFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 522 + } + }, + { + "name": "ImGui_GetFont", + "original_fully_qualified_name": "ImGui::GetFont", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current font" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 523 + } + }, + { + "name": "ImGui_GetFontSize", + "original_fully_qualified_name": "ImGui::GetFontSize", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current scaled font size (= height in pixels). AFTER global scale factors applied. *IMPORTANT* DO NOT PASS THIS VALUE TO PushFont()! Use ImGui::GetStyle().FontSizeBase to get value before global scale factors." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 524 + } + }, + { + "name": "ImGui_GetFontBaked", + "original_fully_qualified_name": "ImGui::GetFontBaked", + "return_type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current font bound at current size // == GetFont()->GetFontBaked(GetFontSize())" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 525 + } + }, + { + "name": "ImGui_PushStyleColor", + "original_fully_qualified_name": "ImGui::PushStyleColor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Parameters stacks (shared)" + ], + "attached": "// modify a style color. always use this if you modify the style after NewFrame()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 528 + } + }, + { + "name": "ImGui_PushStyleColorImVec4", + "original_fully_qualified_name": "ImGui::PushStyleColor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 529 + } + }, + { + "name": "ImGui_PopStyleColor", + "original_fully_qualified_name": "ImGui::PopStyleColor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied count = 1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 530 + } + }, + { + "name": "ImGui_PopStyleColorEx", + "original_fully_qualified_name": "ImGui::PopStyleColor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 530 + } + }, + { + "name": "ImGui_PushStyleVar", + "original_fully_qualified_name": "ImGui::PushStyleVar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiStyleVar", + "description": { + "kind": "User", + "name": "ImGuiStyleVar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// modify a style float variable. always use this if you modify the style after NewFrame()!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 531 + } + }, + { + "name": "ImGui_PushStyleVarImVec2", + "original_fully_qualified_name": "ImGui::PushStyleVar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiStyleVar", + "description": { + "kind": "User", + "name": "ImGuiStyleVar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// modify a style ImVec2 variable. \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 532 + } + }, + { + "name": "ImGui_PushStyleVarX", + "original_fully_qualified_name": "ImGui::PushStyleVarX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiStyleVar", + "description": { + "kind": "User", + "name": "ImGuiStyleVar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// modify X component of a style ImVec2 variable. \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 533 + } + }, + { + "name": "ImGui_PushStyleVarY", + "original_fully_qualified_name": "ImGui::PushStyleVarY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiStyleVar", + "description": { + "kind": "User", + "name": "ImGuiStyleVar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// modify Y component of a style ImVec2 variable. \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 534 + } + }, + { + "name": "ImGui_PopStyleVar", + "original_fully_qualified_name": "ImGui::PopStyleVar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied count = 1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 535 + } + }, + { + "name": "ImGui_PopStyleVarEx", + "original_fully_qualified_name": "ImGui::PopStyleVar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 535 + } + }, + { + "name": "ImGui_PushItemFlag", + "original_fully_qualified_name": "ImGui::PushItemFlag", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "option", + "type": { + "declaration": "ImGuiItemFlags", + "description": { + "kind": "User", + "name": "ImGuiItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "enabled", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// modify specified shared item flag, e.g. PushItemFlag(ImGuiItemFlags_NoTabStop, true)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 536 + } + }, + { + "name": "ImGui_PopItemFlag", + "original_fully_qualified_name": "ImGui::PopItemFlag", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 537 + } + }, + { + "name": "ImGui_PushItemWidth", + "original_fully_qualified_name": "ImGui::PushItemWidth", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "item_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Parameters stacks (current window)" + ], + "attached": "// push width of items for common large \"item+label\" widgets. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 540 + } + }, + { + "name": "ImGui_PopItemWidth", + "original_fully_qualified_name": "ImGui::PopItemWidth", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 541 + } + }, + { + "name": "ImGui_SetNextItemWidth", + "original_fully_qualified_name": "ImGui::SetNextItemWidth", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "item_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set width of the _next_ common large \"item+label\" widget. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 542 + } + }, + { + "name": "ImGui_CalcItemWidth", + "original_fully_qualified_name": "ImGui::CalcItemWidth", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// width of item given pushed settings and current cursor position. NOT necessarily the width of last item unlike most 'Item' functions." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 543 + } + }, + { + "name": "ImGui_PushTextWrapPos", + "original_fully_qualified_name": "ImGui::PushTextWrapPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "wrap_local_pos_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// push word-wrapping position for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x' position in window local space" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 544 + } + }, + { + "name": "ImGui_PopTextWrapPos", + "original_fully_qualified_name": "ImGui::PopTextWrapPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 545 + } + }, + { + "name": "ImGui_GetFontTexUvWhitePixel", + "original_fully_qualified_name": "ImGui::GetFontTexUvWhitePixel", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Style read access", + "// - Use the ShowStyleEditor() function to interactively see/edit the colors." + ], + "attached": "// get UV coordinate for a white pixel, useful to draw custom shapes via the ImDrawList API" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 549 + } + }, + { + "name": "ImGui_GetColorU32", + "original_fully_qualified_name": "ImGui::GetColorU32", + "return_type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied alpha_mul = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 550 + } + }, + { + "name": "ImGui_GetColorU32Ex", + "original_fully_qualified_name": "ImGui::GetColorU32", + "return_type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "alpha_mul", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// retrieve given style color with style alpha applied and optional extra alpha multiplier, packed as a 32-bit value suitable for ImDrawList" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 550 + } + }, + { + "name": "ImGui_GetColorU32ImVec4", + "original_fully_qualified_name": "ImGui::GetColorU32", + "return_type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 551 + } + }, + { + "name": "ImGui_GetColorU32ImU32", + "original_fully_qualified_name": "ImGui::GetColorU32", + "return_type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied alpha_mul = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 552 + } + }, + { + "name": "ImGui_GetColorU32ImU32Ex", + "original_fully_qualified_name": "ImGui::GetColorU32", + "return_type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "alpha_mul", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 552 + } + }, + { + "name": "ImGui_GetStyleColorVec4", + "original_fully_qualified_name": "ImGui::GetStyleColorVec4", + "return_type": { + "declaration": "const ImVec4*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "User", + "name": "ImVec4", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// retrieve style color as stored in ImGuiStyle structure. use to feed back into PushStyleColor(), otherwise use GetColorU32() to get style color with style alpha baked in." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 553 + } + }, + { + "name": "ImGui_GetCursorScreenPos", + "original_fully_qualified_name": "ImGui::GetCursorScreenPos", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Layout cursor positioning", + "// - By \"cursor\" we mean the current output position.", + "// - The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down.", + "// - You can call SameLine() between widgets to undo the last carriage return and output at the right of the preceding widget.", + "// - YOU CAN DO 99% OF WHAT YOU NEED WITH ONLY GetCursorScreenPos() and GetContentRegionAvail().", + "// - Attention! We currently have inconsistencies between window-local and absolute positions we will aim to fix with future API:", + "// - Absolute coordinate: GetCursorScreenPos(), SetCursorScreenPos(), all ImDrawList:: functions. -> this is the preferred way forward.", + "// - Window-local coordinates: SameLine(offset), GetCursorPos(), SetCursorPos(), GetCursorStartPos(), PushTextWrapPos()", + "// - Window-local coordinates: GetContentRegionMax(), GetWindowContentRegionMin(), GetWindowContentRegionMax() --> all obsoleted. YOU DON'T NEED THEM.", + "// - GetCursorScreenPos() = GetCursorPos() + GetWindowPos(). GetWindowPos() is almost only ever useful to convert from window-local to absolute coordinates. Try not to use it." + ], + "attached": "// cursor position, absolute coordinates. THIS IS YOUR BEST FRIEND (prefer using this rather than GetCursorPos(), also more useful to work with ImDrawList API)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 565 + } + }, + { + "name": "ImGui_SetCursorScreenPos", + "original_fully_qualified_name": "ImGui::SetCursorScreenPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// cursor position, absolute coordinates. THIS IS YOUR BEST FRIEND." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 566 + } + }, + { + "name": "ImGui_GetContentRegionAvail", + "original_fully_qualified_name": "ImGui::GetContentRegionAvail", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// available space from current position. THIS IS YOUR BEST FRIEND." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 567 + } + }, + { + "name": "ImGui_GetCursorPos", + "original_fully_qualified_name": "ImGui::GetCursorPos", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [window-local] cursor position in window-local coordinates. This is not your best friend." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 568 + } + }, + { + "name": "ImGui_GetCursorPosX", + "original_fully_qualified_name": "ImGui::GetCursorPosX", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [window-local] \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 569 + } + }, + { + "name": "ImGui_GetCursorPosY", + "original_fully_qualified_name": "ImGui::GetCursorPosY", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [window-local] \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 570 + } + }, + { + "name": "ImGui_SetCursorPos", + "original_fully_qualified_name": "ImGui::SetCursorPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "local_pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [window-local] \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 571 + } + }, + { + "name": "ImGui_SetCursorPosX", + "original_fully_qualified_name": "ImGui::SetCursorPosX", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "local_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [window-local] \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 572 + } + }, + { + "name": "ImGui_SetCursorPosY", + "original_fully_qualified_name": "ImGui::SetCursorPosY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "local_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [window-local] \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 573 + } + }, + { + "name": "ImGui_GetCursorStartPos", + "original_fully_qualified_name": "ImGui::GetCursorStartPos", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [window-local] initial cursor position, in window-local coordinates. Call GetCursorScreenPos() after Begin() to get the absolute coordinates version." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 574 + } + }, + { + "name": "ImGui_Separator", + "original_fully_qualified_name": "ImGui::Separator", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Other layout functions" + ], + "attached": "// separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 577 + } + }, + { + "name": "ImGui_SameLine", + "original_fully_qualified_name": "ImGui::SameLine", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied offset_from_start_x = 0.0f, spacing = -1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 578 + } + }, + { + "name": "ImGui_SameLineEx", + "original_fully_qualified_name": "ImGui::SameLine", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "offset_from_start_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "spacing", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// call between widgets or groups to layout them horizontally. X position given in window coordinates." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 578 + } + }, + { + "name": "ImGui_NewLine", + "original_fully_qualified_name": "ImGui::NewLine", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// undo a SameLine() or force a new line when in a horizontal-layout context." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 579 + } + }, + { + "name": "ImGui_Spacing", + "original_fully_qualified_name": "ImGui::Spacing", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// add vertical spacing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 580 + } + }, + { + "name": "ImGui_Dummy", + "original_fully_qualified_name": "ImGui::Dummy", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// add a dummy item of given size. unlike InvisibleButton(), Dummy() won't take the mouse click or be navigable into." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 581 + } + }, + { + "name": "ImGui_Indent", + "original_fully_qualified_name": "ImGui::Indent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied indent_w = 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 582 + } + }, + { + "name": "ImGui_IndentEx", + "original_fully_qualified_name": "ImGui::Indent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "indent_w", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// move content position toward the right, by indent_w, or style.IndentSpacing if indent_w <= 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 582 + } + }, + { + "name": "ImGui_Unindent", + "original_fully_qualified_name": "ImGui::Unindent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied indent_w = 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 583 + } + }, + { + "name": "ImGui_UnindentEx", + "original_fully_qualified_name": "ImGui::Unindent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "indent_w", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// move content position back to the left, by indent_w, or style.IndentSpacing if indent_w <= 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 583 + } + }, + { + "name": "ImGui_BeginGroup", + "original_fully_qualified_name": "ImGui::BeginGroup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// lock horizontal starting position" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 584 + } + }, + { + "name": "ImGui_EndGroup", + "original_fully_qualified_name": "ImGui::EndGroup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// unlock horizontal starting position + capture the whole group bounding box into one \"item\" (so you can use IsItemHovered() or layout primitives such as SameLine() on whole group, etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 585 + } + }, + { + "name": "ImGui_AlignTextToFramePadding", + "original_fully_qualified_name": "ImGui::AlignTextToFramePadding", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// vertically align upcoming text baseline to FramePadding.y so that it will align properly to regularly framed items (call if you have text on a line before a framed item)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 586 + } + }, + { + "name": "ImGui_GetTextLineHeight", + "original_fully_qualified_name": "ImGui::GetTextLineHeight", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ~ FontSize" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 587 + } + }, + { + "name": "ImGui_GetTextLineHeightWithSpacing", + "original_fully_qualified_name": "ImGui::GetTextLineHeightWithSpacing", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ~ FontSize + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of text)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 588 + } + }, + { + "name": "ImGui_GetFrameHeight", + "original_fully_qualified_name": "ImGui::GetFrameHeight", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ~ FontSize + style.FramePadding.y * 2" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 589 + } + }, + { + "name": "ImGui_GetFrameHeightWithSpacing", + "original_fully_qualified_name": "ImGui::GetFrameHeightWithSpacing", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ~ FontSize + style.FramePadding.y * 2 + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of framed widgets)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 590 + } + }, + { + "name": "ImGui_PushID", + "original_fully_qualified_name": "ImGui::PushID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// ID stack/scopes", + "// Read the FAQ (docs/FAQ.md or http://dearimgui.com/faq) for more details about how ID are handled in dear imgui.", + "// - Those questions are answered and impacted by understanding of the ID stack system:", + "// - \"Q: Why is my widget not reacting when I click on it?\"", + "// - \"Q: How can I have widgets with an empty label?\"", + "// - \"Q: How can I have multiple widgets with the same label?\"", + "// - Short version: ID are hashes of the entire ID stack. If you are creating widgets in a loop you most likely", + "// want to push a unique identifier (e.g. object pointer, loop index) to uniquely differentiate them.", + "// - You can also use the \"Label##foobar\" syntax within widget label to distinguish them from each others.", + "// - In this header file we use the \"label\"/\"name\" terminology to denote a string that will be displayed + used as an ID,", + "// whereas \"str_id\" denote a string that is only used as an ID and not normally displayed." + ], + "attached": "// push string into the ID stack (will hash string)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 603 + } + }, + { + "name": "ImGui_PushIDStr", + "original_fully_qualified_name": "ImGui::PushID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str_id_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str_id_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// push string into the ID stack (will hash string)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 604 + } + }, + { + "name": "ImGui_PushIDPtr", + "original_fully_qualified_name": "ImGui::PushID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ptr_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// push pointer into the ID stack (will hash pointer)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 605 + } + }, + { + "name": "ImGui_PushIDInt", + "original_fully_qualified_name": "ImGui::PushID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "int_id", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// push integer into the ID stack (will hash integer)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 606 + } + }, + { + "name": "ImGui_PopID", + "original_fully_qualified_name": "ImGui::PopID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// pop from the ID stack." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 607 + } + }, + { + "name": "ImGui_GetID", + "original_fully_qualified_name": "ImGui::GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 608 + } + }, + { + "name": "ImGui_GetIDStr", + "original_fully_qualified_name": "ImGui::GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "str_id_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str_id_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 609 + } + }, + { + "name": "ImGui_GetIDPtr", + "original_fully_qualified_name": "ImGui::GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "ptr_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 610 + } + }, + { + "name": "ImGui_GetIDInt", + "original_fully_qualified_name": "ImGui::GetID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "int_id", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 611 + } + }, + { + "name": "ImGui_TextUnformatted", + "original_fully_qualified_name": "ImGui::TextUnformatted", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Text" + ], + "attached": "// Implied text_end = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 614 + } + }, + { + "name": "ImGui_TextUnformattedEx", + "original_fully_qualified_name": "ImGui::TextUnformatted", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// raw text without formatting. Roughly equivalent to Text(\"%s\", text) but: A) doesn't require null terminated string if 'text_end' is specified, B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 614 + } + }, + { + "name": "ImGui_Text", + "original_fully_qualified_name": "ImGui::Text", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// formatted text" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 615 + } + }, + { + "name": "ImGui_TextV", + "original_fully_qualified_name": "ImGui::TextV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 616 + } + }, + { + "name": "ImGui_TextColored", + "original_fully_qualified_name": "ImGui::TextColored", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 617 + } + }, + { + "name": "ImGui_TextColoredV", + "original_fully_qualified_name": "ImGui::TextColoredV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 618 + } + }, + { + "name": "ImGui_TextDisabled", + "original_fully_qualified_name": "ImGui::TextDisabled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// shortcut for PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]); Text(fmt, ...); PopStyleColor();" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 619 + } + }, + { + "name": "ImGui_TextDisabledV", + "original_fully_qualified_name": "ImGui::TextDisabledV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 620 + } + }, + { + "name": "ImGui_TextWrapped", + "original_fully_qualified_name": "ImGui::TextWrapped", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// shortcut for PushTextWrapPos(0.0f); Text(fmt, ...); PopTextWrapPos();. Note that this won't work on an auto-resizing window if there's no other widgets to extend the window width, yoy may need to set a size using SetNextWindowSize()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 621 + } + }, + { + "name": "ImGui_TextWrappedV", + "original_fully_qualified_name": "ImGui::TextWrappedV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 622 + } + }, + { + "name": "ImGui_LabelText", + "original_fully_qualified_name": "ImGui::LabelText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// display text+label aligned the same way as value+label widgets" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 623 + } + }, + { + "name": "ImGui_LabelTextV", + "original_fully_qualified_name": "ImGui::LabelTextV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 624 + } + }, + { + "name": "ImGui_BulletText", + "original_fully_qualified_name": "ImGui::BulletText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// shortcut for Bullet()+Text()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 625 + } + }, + { + "name": "ImGui_BulletTextV", + "original_fully_qualified_name": "ImGui::BulletTextV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 626 + } + }, + { + "name": "ImGui_SeparatorText", + "original_fully_qualified_name": "ImGui::SeparatorText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// currently: formatted text with a horizontal line" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 627 + } + }, + { + "name": "ImGui_Button", + "original_fully_qualified_name": "ImGui::Button", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Main", + "// - Most widgets return true when the value has been changed or when pressed/selected", + "// - You may also use one of the many IsItemXXX functions (e.g. IsItemActive, IsItemHovered, etc.) to query widget state." + ], + "attached": "// Implied size = ImVec2(0, 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 632 + } + }, + { + "name": "ImGui_ButtonEx", + "original_fully_qualified_name": "ImGui::Button", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// button" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 632 + } + }, + { + "name": "ImGui_SmallButton", + "original_fully_qualified_name": "ImGui::SmallButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// button with (FramePadding.y == 0) to easily embed within text" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 633 + } + }, + { + "name": "ImGui_InvisibleButton", + "original_fully_qualified_name": "ImGui::InvisibleButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiButtonFlags", + "description": { + "kind": "User", + "name": "ImGuiButtonFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 634 + } + }, + { + "name": "ImGui_ArrowButton", + "original_fully_qualified_name": "ImGui::ArrowButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "dir", + "type": { + "declaration": "ImGuiDir", + "description": { + "kind": "User", + "name": "ImGuiDir" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// square button with an arrow shape" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 635 + } + }, + { + "name": "ImGui_Checkbox", + "original_fully_qualified_name": "ImGui::Checkbox", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 636 + } + }, + { + "name": "ImGui_CheckboxFlagsIntPtr", + "original_fully_qualified_name": "ImGui::CheckboxFlags", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags_value", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 637 + } + }, + { + "name": "ImGui_CheckboxFlagsUintPtr", + "original_fully_qualified_name": "ImGui::CheckboxFlags", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "unsigned int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags_value", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 638 + } + }, + { + "name": "ImGui_RadioButton", + "original_fully_qualified_name": "ImGui::RadioButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "active", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// use with e.g. if (RadioButton(\"one\", my_value==1)) { my_value = 1; }" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 639 + } + }, + { + "name": "ImGui_RadioButtonIntPtr", + "original_fully_qualified_name": "ImGui::RadioButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_button", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// shortcut to handle the above pattern when value is an integer" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 640 + } + }, + { + "name": "ImGui_ProgressBar", + "original_fully_qualified_name": "ImGui::ProgressBar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fraction", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_arg", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(-FLT_MIN, 0)", + "is_instance_pointer": false + }, + { + "name": "overlay", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 641 + } + }, + { + "name": "ImGui_Bullet", + "original_fully_qualified_name": "ImGui::Bullet", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 642 + } + }, + { + "name": "ImGui_TextLink", + "original_fully_qualified_name": "ImGui::TextLink", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// hyperlink text button, return true when clicked" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 643 + } + }, + { + "name": "ImGui_TextLinkOpenURL", + "original_fully_qualified_name": "ImGui::TextLinkOpenURL", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied url = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 644 + } + }, + { + "name": "ImGui_TextLinkOpenURLEx", + "original_fully_qualified_name": "ImGui::TextLinkOpenURL", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "url", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// hyperlink text button, automatically open file/url when clicked" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 644 + } + }, + { + "name": "ImGui_Image", + "original_fully_qualified_name": "ImGui::Image", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Images", + "// - Read about ImTextureID/ImTextureRef here: https://github.com/ocornut/imgui/wiki/Image-Loading-and-Displaying-Examples", + "// - 'uv0' and 'uv1' are texture coordinates. Read about them from the same link above.", + "// - Image() pads adds style.ImageBorderSize on each side, ImageButton() adds style.FramePadding on each side.", + "// - ImageButton() draws a background based on regular Button() color + optionally an inner background if specified.", + "// - An obsolete version of Image(), before 1.91.9 (March 2025), had a 'tint_col' parameter which is now supported by the ImageWithBg() function." + ], + "attached": "// Implied uv0 = ImVec2(0, 0), uv1 = ImVec2(1, 1)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 652 + } + }, + { + "name": "ImGui_ImageEx", + "original_fully_qualified_name": "ImGui::Image", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv0", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "uv1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(1, 1)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 652 + } + }, + { + "name": "ImGui_ImageWithBg", + "original_fully_qualified_name": "ImGui::ImageWithBg", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied uv0 = ImVec2(0, 0), uv1 = ImVec2(1, 1), bg_col = ImVec4(0, 0, 0, 0), tint_col = ImVec4(1, 1, 1, 1)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 653 + } + }, + { + "name": "ImGui_ImageWithBgEx", + "original_fully_qualified_name": "ImGui::ImageWithBg", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv0", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "uv1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(1, 1)", + "is_instance_pointer": false + }, + { + "name": "bg_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec4(0, 0, 0, 0)", + "is_instance_pointer": false + }, + { + "name": "tint_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec4(1, 1, 1, 1)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 653 + } + }, + { + "name": "ImGui_ImageButton", + "original_fully_qualified_name": "ImGui::ImageButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied uv0 = ImVec2(0, 0), uv1 = ImVec2(1, 1), bg_col = ImVec4(0, 0, 0, 0), tint_col = ImVec4(1, 1, 1, 1)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 654 + } + }, + { + "name": "ImGui_ImageButtonEx", + "original_fully_qualified_name": "ImGui::ImageButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv0", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "uv1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(1, 1)", + "is_instance_pointer": false + }, + { + "name": "bg_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec4(0, 0, 0, 0)", + "is_instance_pointer": false + }, + { + "name": "tint_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec4(1, 1, 1, 1)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 654 + } + }, + { + "name": "ImGui_BeginCombo", + "original_fully_qualified_name": "ImGui::BeginCombo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "preview_value", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiComboFlags", + "description": { + "kind": "User", + "name": "ImGuiComboFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Combo Box (Dropdown)", + "// - The BeginCombo()/EndCombo() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() items.", + "// - The old Combo() api are helpers over BeginCombo()/EndCombo() which are kept available for convenience purpose. This is analogous to how ListBox are created." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 659 + } + }, + { + "name": "ImGui_EndCombo", + "original_fully_qualified_name": "ImGui::EndCombo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndCombo() if BeginCombo() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 660 + } + }, + { + "name": "ImGui_ComboChar", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items", + "type": { + "declaration": "const char*const[]", + "description": { + "kind": "Array", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + }, + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "", + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied popup_max_height_in_items = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 661 + } + }, + { + "name": "ImGui_ComboCharEx", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items", + "type": { + "declaration": "const char*const[]", + "description": { + "kind": "Array", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + }, + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "", + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_max_height_in_items", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 661 + } + }, + { + "name": "ImGui_Combo", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_separated_by_zeros", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied popup_max_height_in_items = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 662 + } + }, + { + "name": "ImGui_ComboEx", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_separated_by_zeros", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_max_height_in_items", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Separate items with \\0 within a string, end item-list with \\0\\0. e.g. \"One\\0Two\\0Three\\0\"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 662 + } + }, + { + "name": "ImGui_ComboCallback", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "getter", + "type": { + "declaration": "const char* (*getter)(void* user_data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied popup_max_height_in_items = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 663 + } + }, + { + "name": "ImGui_ComboCallbackEx", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "getter", + "type": { + "declaration": "const char* (*getter)(void* user_data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_max_height_in_items", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 663 + } + }, + { + "name": "ImGui_DragFloat", + "original_fully_qualified_name": "ImGui::DragFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Drag Sliders", + "// - CTRL+Click on any drag box to turn them into an input box. Manually input values aren't clamped by default and can go off-bounds. Use ImGuiSliderFlags_AlwaysClamp to always clamp.", + "// - For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every function, note that a 'float v[X]' function argument is the same as 'float* v',", + "// the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x", + "// - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. \"%.3f\" -> 1.234; \"%5.2f secs\" -> 01.23 secs; \"Biscuit: %.0f\" -> Biscuit: 1; etc.", + "// - Format string may also be set to NULL or use the default format (\"%f\" or \"%d\").", + "// - Speed are per-pixel of mouse movement (v_speed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For keyboard/gamepad navigation, minimum speed is Max(v_speed, minimum_step_at_given_precision).", + "// - Use v_min < v_max to clamp edits to given limits. Note that CTRL+Click manual input can override those limits if ImGuiSliderFlags_AlwaysClamp is not used.", + "// - Use v_max = FLT_MAX / INT_MAX etc to avoid clamping to a maximum, same with v_min = -FLT_MAX / INT_MIN to avoid clamping to a minimum.", + "// - We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.", + "// - Legacy: Pre-1.78 there are DragXXX() function signatures that take a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.", + "// If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361" + ], + "attached": "// Implied v_speed = 1.0f, v_min = 0.0f, v_max = 0.0f, format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 677 + } + }, + { + "name": "ImGui_DragFloatEx", + "original_fully_qualified_name": "ImGui::DragFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// If v_min >= v_max we have no bound" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 677 + } + }, + { + "name": "ImGui_DragFloat2", + "original_fully_qualified_name": "ImGui::DragFloat2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0.0f, v_max = 0.0f, format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 678 + } + }, + { + "name": "ImGui_DragFloat2Ex", + "original_fully_qualified_name": "ImGui::DragFloat2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 678 + } + }, + { + "name": "ImGui_DragFloat3", + "original_fully_qualified_name": "ImGui::DragFloat3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0.0f, v_max = 0.0f, format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 679 + } + }, + { + "name": "ImGui_DragFloat3Ex", + "original_fully_qualified_name": "ImGui::DragFloat3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 679 + } + }, + { + "name": "ImGui_DragFloat4", + "original_fully_qualified_name": "ImGui::DragFloat4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0.0f, v_max = 0.0f, format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 680 + } + }, + { + "name": "ImGui_DragFloat4Ex", + "original_fully_qualified_name": "ImGui::DragFloat4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 680 + } + }, + { + "name": "ImGui_DragFloatRange2", + "original_fully_qualified_name": "ImGui::DragFloatRange2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_min", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_max", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0.0f, v_max = 0.0f, format = \"%.3f\", format_max = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 681 + } + }, + { + "name": "ImGui_DragFloatRange2Ex", + "original_fully_qualified_name": "ImGui::DragFloatRange2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_min", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_max", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "format_max", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 681 + } + }, + { + "name": "ImGui_DragInt", + "original_fully_qualified_name": "ImGui::DragInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0, v_max = 0, format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 682 + } + }, + { + "name": "ImGui_DragIntEx", + "original_fully_qualified_name": "ImGui::DragInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// If v_min >= v_max we have no bound" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 682 + } + }, + { + "name": "ImGui_DragInt2", + "original_fully_qualified_name": "ImGui::DragInt2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0, v_max = 0, format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 683 + } + }, + { + "name": "ImGui_DragInt2Ex", + "original_fully_qualified_name": "ImGui::DragInt2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 683 + } + }, + { + "name": "ImGui_DragInt3", + "original_fully_qualified_name": "ImGui::DragInt3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0, v_max = 0, format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 684 + } + }, + { + "name": "ImGui_DragInt3Ex", + "original_fully_qualified_name": "ImGui::DragInt3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 684 + } + }, + { + "name": "ImGui_DragInt4", + "original_fully_qualified_name": "ImGui::DragInt4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0, v_max = 0, format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 685 + } + }, + { + "name": "ImGui_DragInt4Ex", + "original_fully_qualified_name": "ImGui::DragInt4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 685 + } + }, + { + "name": "ImGui_DragIntRange2", + "original_fully_qualified_name": "ImGui::DragIntRange2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_min", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_max", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, v_min = 0, v_max = 0, format = \"%d\", format_max = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 686 + } + }, + { + "name": "ImGui_DragIntRange2Ex", + "original_fully_qualified_name": "ImGui::DragIntRange2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_min", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_current_max", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "format_max", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 686 + } + }, + { + "name": "ImGui_DragScalar", + "original_fully_qualified_name": "ImGui::DragScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, p_min = NULL, p_max = NULL, format = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 687 + } + }, + { + "name": "ImGui_DragScalarEx", + "original_fully_qualified_name": "ImGui::DragScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 687 + } + }, + { + "name": "ImGui_DragScalarN", + "original_fully_qualified_name": "ImGui::DragScalarN", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "components", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_speed = 1.0f, p_min = NULL, p_max = NULL, format = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 688 + } + }, + { + "name": "ImGui_DragScalarNEx", + "original_fully_qualified_name": "ImGui::DragScalarN", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "components", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_speed", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 688 + } + }, + { + "name": "ImGui_SliderFloat", + "original_fully_qualified_name": "ImGui::SliderFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Regular Sliders", + "// - CTRL+Click on any slider to turn them into an input box. Manually input values aren't clamped by default and can go off-bounds. Use ImGuiSliderFlags_AlwaysClamp to always clamp.", + "// - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. \"%.3f\" -> 1.234; \"%5.2f secs\" -> 01.23 secs; \"Biscuit: %.0f\" -> Biscuit: 1; etc.", + "// - Format string may also be set to NULL or use the default format (\"%f\" or \"%d\").", + "// - Legacy: Pre-1.78 there are SliderXXX() function signatures that take a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.", + "// If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361" + ], + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 696 + } + }, + { + "name": "ImGui_SliderFloatEx", + "original_fully_qualified_name": "ImGui::SliderFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// adjust format to decorate the value with a prefix or a suffix for in-slider labels or unit display." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 696 + } + }, + { + "name": "ImGui_SliderFloat2", + "original_fully_qualified_name": "ImGui::SliderFloat2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 697 + } + }, + { + "name": "ImGui_SliderFloat2Ex", + "original_fully_qualified_name": "ImGui::SliderFloat2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 697 + } + }, + { + "name": "ImGui_SliderFloat3", + "original_fully_qualified_name": "ImGui::SliderFloat3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 698 + } + }, + { + "name": "ImGui_SliderFloat3Ex", + "original_fully_qualified_name": "ImGui::SliderFloat3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 698 + } + }, + { + "name": "ImGui_SliderFloat4", + "original_fully_qualified_name": "ImGui::SliderFloat4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 699 + } + }, + { + "name": "ImGui_SliderFloat4Ex", + "original_fully_qualified_name": "ImGui::SliderFloat4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 699 + } + }, + { + "name": "ImGui_SliderAngle", + "original_fully_qualified_name": "ImGui::SliderAngle", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_rad", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied v_degrees_min = -360.0f, v_degrees_max = +360.0f, format = \"%.0f deg\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 700 + } + }, + { + "name": "ImGui_SliderAngleEx", + "original_fully_qualified_name": "ImGui::SliderAngle", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_rad", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_degrees_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-360.0f", + "is_instance_pointer": false + }, + { + "name": "v_degrees_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "+360.0f", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.0f deg\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 700 + } + }, + { + "name": "ImGui_SliderInt", + "original_fully_qualified_name": "ImGui::SliderInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 701 + } + }, + { + "name": "ImGui_SliderIntEx", + "original_fully_qualified_name": "ImGui::SliderInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 701 + } + }, + { + "name": "ImGui_SliderInt2", + "original_fully_qualified_name": "ImGui::SliderInt2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 702 + } + }, + { + "name": "ImGui_SliderInt2Ex", + "original_fully_qualified_name": "ImGui::SliderInt2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 702 + } + }, + { + "name": "ImGui_SliderInt3", + "original_fully_qualified_name": "ImGui::SliderInt3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 703 + } + }, + { + "name": "ImGui_SliderInt3Ex", + "original_fully_qualified_name": "ImGui::SliderInt3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 703 + } + }, + { + "name": "ImGui_SliderInt4", + "original_fully_qualified_name": "ImGui::SliderInt4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 704 + } + }, + { + "name": "ImGui_SliderInt4Ex", + "original_fully_qualified_name": "ImGui::SliderInt4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 704 + } + }, + { + "name": "ImGui_SliderScalar", + "original_fully_qualified_name": "ImGui::SliderScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 705 + } + }, + { + "name": "ImGui_SliderScalarEx", + "original_fully_qualified_name": "ImGui::SliderScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 705 + } + }, + { + "name": "ImGui_SliderScalarN", + "original_fully_qualified_name": "ImGui::SliderScalarN", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "components", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 706 + } + }, + { + "name": "ImGui_SliderScalarNEx", + "original_fully_qualified_name": "ImGui::SliderScalarN", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "components", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 706 + } + }, + { + "name": "ImGui_VSliderFloat", + "original_fully_qualified_name": "ImGui::VSliderFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 707 + } + }, + { + "name": "ImGui_VSliderFloatEx", + "original_fully_qualified_name": "ImGui::VSliderFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 707 + } + }, + { + "name": "ImGui_VSliderInt", + "original_fully_qualified_name": "ImGui::VSliderInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%d\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 708 + } + }, + { + "name": "ImGui_VSliderIntEx", + "original_fully_qualified_name": "ImGui::VSliderInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_min", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v_max", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%d\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 708 + } + }, + { + "name": "ImGui_VSliderScalar", + "original_fully_qualified_name": "ImGui::VSliderScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 709 + } + }, + { + "name": "ImGui_VSliderScalarEx", + "original_fully_qualified_name": "ImGui::VSliderScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSliderFlags", + "description": { + "kind": "User", + "name": "ImGuiSliderFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 709 + } + }, + { + "name": "ImGui_InputText", + "original_fully_qualified_name": "ImGui::InputText", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Input with Keyboard", + "// - If you want to use InputText() with std::string or any custom dynamic string type, see misc/cpp/imgui_stdlib.h and comments in imgui_demo.cpp.", + "// - Most of the ImGuiInputTextFlags flags are only useful for InputText() and not for InputFloatX, InputIntX, InputDouble etc." + ], + "attached": "// Implied callback = NULL, user_data = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 714 + } + }, + { + "name": "ImGui_InputTextEx", + "original_fully_qualified_name": "ImGui::InputText", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "callback", + "type": { + "declaration": "ImGuiInputTextCallback", + "description": { + "kind": "User", + "name": "ImGuiInputTextCallback" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 714 + } + }, + { + "name": "ImGui_InputTextMultiline", + "original_fully_qualified_name": "ImGui::InputTextMultiline", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied size = ImVec2(0, 0), flags = 0, callback = NULL, user_data = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 715 + } + }, + { + "name": "ImGui_InputTextMultilineEx", + "original_fully_qualified_name": "ImGui::InputTextMultiline", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "callback", + "type": { + "declaration": "ImGuiInputTextCallback", + "description": { + "kind": "User", + "name": "ImGuiInputTextCallback" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 715 + } + }, + { + "name": "ImGui_InputTextWithHint", + "original_fully_qualified_name": "ImGui::InputTextWithHint", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hint", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied callback = NULL, user_data = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 716 + } + }, + { + "name": "ImGui_InputTextWithHintEx", + "original_fully_qualified_name": "ImGui::InputTextWithHint", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "hint", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf", + "type": { + "declaration": "char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "buf_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "callback", + "type": { + "declaration": "ImGuiInputTextCallback", + "description": { + "kind": "User", + "name": "ImGuiInputTextCallback" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 716 + } + }, + { + "name": "ImGui_InputFloat", + "original_fully_qualified_name": "ImGui::InputFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied step = 0.0f, step_fast = 0.0f, format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 717 + } + }, + { + "name": "ImGui_InputFloatEx", + "original_fully_qualified_name": "ImGui::InputFloat", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "step", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "step_fast", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 717 + } + }, + { + "name": "ImGui_InputFloat2", + "original_fully_qualified_name": "ImGui::InputFloat2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 718 + } + }, + { + "name": "ImGui_InputFloat2Ex", + "original_fully_qualified_name": "ImGui::InputFloat2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 718 + } + }, + { + "name": "ImGui_InputFloat3", + "original_fully_qualified_name": "ImGui::InputFloat3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 719 + } + }, + { + "name": "ImGui_InputFloat3Ex", + "original_fully_qualified_name": "ImGui::InputFloat3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 719 + } + }, + { + "name": "ImGui_InputFloat4", + "original_fully_qualified_name": "ImGui::InputFloat4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied format = \"%.3f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 720 + } + }, + { + "name": "ImGui_InputFloat4Ex", + "original_fully_qualified_name": "ImGui::InputFloat4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.3f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 720 + } + }, + { + "name": "ImGui_InputInt", + "original_fully_qualified_name": "ImGui::InputInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied step = 1, step_fast = 100, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 721 + } + }, + { + "name": "ImGui_InputIntEx", + "original_fully_qualified_name": "ImGui::InputInt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "step", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + }, + { + "name": "step_fast", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "100", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 721 + } + }, + { + "name": "ImGui_InputInt2", + "original_fully_qualified_name": "ImGui::InputInt2", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[2]", + "description": { + "kind": "Array", + "bounds": "2", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "2", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 722 + } + }, + { + "name": "ImGui_InputInt3", + "original_fully_qualified_name": "ImGui::InputInt3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 723 + } + }, + { + "name": "ImGui_InputInt4", + "original_fully_qualified_name": "ImGui::InputInt4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "int[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 724 + } + }, + { + "name": "ImGui_InputDouble", + "original_fully_qualified_name": "ImGui::InputDouble", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "double*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "double" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied step = 0.0, step_fast = 0.0, format = \"%.6f\", flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 725 + } + }, + { + "name": "ImGui_InputDoubleEx", + "original_fully_qualified_name": "ImGui::InputDouble", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "double*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "double" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "step", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0", + "is_instance_pointer": false + }, + { + "name": "step_fast", + "type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"%.6f\"", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 725 + } + }, + { + "name": "ImGui_InputScalar", + "original_fully_qualified_name": "ImGui::InputScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied p_step = NULL, p_step_fast = NULL, format = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 726 + } + }, + { + "name": "ImGui_InputScalarEx", + "original_fully_qualified_name": "ImGui::InputScalar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_step", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "p_step_fast", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 726 + } + }, + { + "name": "ImGui_InputScalarN", + "original_fully_qualified_name": "ImGui::InputScalarN", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "components", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied p_step = NULL, p_step_fast = NULL, format = NULL, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 727 + } + }, + { + "name": "ImGui_InputScalarNEx", + "original_fully_qualified_name": "ImGui::InputScalarN", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data_type", + "type": { + "declaration": "ImGuiDataType", + "description": { + "kind": "User", + "name": "ImGuiDataType" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "components", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_step", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "p_step_fast", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "format", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputTextFlags", + "description": { + "kind": "User", + "name": "ImGuiInputTextFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 727 + } + }, + { + "name": "ImGui_ColorEdit3", + "original_fully_qualified_name": "ImGui::ColorEdit3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little color square that can be left-clicked to open a picker, and right-clicked to open an option menu.)", + "// - Note that in C++ a 'float v[X]' function argument is the _same_ as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible.", + "// - You can pass the address of a first float element out of a contiguous structure, e.g. &myvector.x" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 732 + } + }, + { + "name": "ImGui_ColorEdit4", + "original_fully_qualified_name": "ImGui::ColorEdit4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 733 + } + }, + { + "name": "ImGui_ColorPicker3", + "original_fully_qualified_name": "ImGui::ColorPicker3", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "float[3]", + "description": { + "kind": "Array", + "bounds": "3", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "3", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 734 + } + }, + { + "name": "ImGui_ColorPicker4", + "original_fully_qualified_name": "ImGui::ColorPicker4", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "float[4]", + "description": { + "kind": "Array", + "bounds": "4", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "4", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "ref_col", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 735 + } + }, + { + "name": "ImGui_ColorButton", + "original_fully_qualified_name": "ImGui::ColorButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "desc_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied size = ImVec2(0, 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 736 + } + }, + { + "name": "ImGui_ColorButtonEx", + "original_fully_qualified_name": "ImGui::ColorButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "desc_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// display a color square/button, hover for details, return true when pressed." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 736 + } + }, + { + "name": "ImGui_SetColorEditOptions", + "original_fully_qualified_name": "ImGui::SetColorEditOptions", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiColorEditFlags", + "description": { + "kind": "User", + "name": "ImGuiColorEditFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// initialize current options (generally on application startup) if you want to select a default format, picker type, etc. User will be able to change many settings, unless you pass the _NoOptions flag to your calls." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 737 + } + }, + { + "name": "ImGui_TreeNode", + "original_fully_qualified_name": "ImGui::TreeNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Trees", + "// - TreeNode functions return true when the node is open, in which case you need to also call TreePop() when you are finished displaying the tree node contents." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 741 + } + }, + { + "name": "ImGui_TreeNodeStr", + "original_fully_qualified_name": "ImGui::TreeNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// helper variation to easily decorelate the id from the displayed string. Read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 742 + } + }, + { + "name": "ImGui_TreeNodePtr", + "original_fully_qualified_name": "ImGui::TreeNode", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "ptr_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 743 + } + }, + { + "name": "ImGui_TreeNodeV", + "original_fully_qualified_name": "ImGui::TreeNodeV", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 744 + } + }, + { + "name": "ImGui_TreeNodeVPtr", + "original_fully_qualified_name": "ImGui::TreeNodeV", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "ptr_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 745 + } + }, + { + "name": "ImGui_TreeNodeEx", + "original_fully_qualified_name": "ImGui::TreeNodeEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 746 + } + }, + { + "name": "ImGui_TreeNodeExStr", + "original_fully_qualified_name": "ImGui::TreeNodeEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 747 + } + }, + { + "name": "ImGui_TreeNodeExPtr", + "original_fully_qualified_name": "ImGui::TreeNodeEx", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "ptr_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 748 + } + }, + { + "name": "ImGui_TreeNodeExV", + "original_fully_qualified_name": "ImGui::TreeNodeExV", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 749 + } + }, + { + "name": "ImGui_TreeNodeExVPtr", + "original_fully_qualified_name": "ImGui::TreeNodeExV", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "ptr_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 750 + } + }, + { + "name": "ImGui_TreePush", + "original_fully_qualified_name": "ImGui::TreePush", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ~ Indent()+PushID(). Already called by TreeNode() when returning true, but you can call TreePush/TreePop yourself if desired." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 751 + } + }, + { + "name": "ImGui_TreePushPtr", + "original_fully_qualified_name": "ImGui::TreePush", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ptr_id", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// \"" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 752 + } + }, + { + "name": "ImGui_TreePop", + "original_fully_qualified_name": "ImGui::TreePop", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// ~ Unindent()+PopID()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 753 + } + }, + { + "name": "ImGui_GetTreeNodeToLabelSpacing", + "original_fully_qualified_name": "ImGui::GetTreeNodeToLabelSpacing", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// horizontal distance preceding label when using TreeNode*() or Bullet() == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 754 + } + }, + { + "name": "ImGui_CollapsingHeader", + "original_fully_qualified_name": "ImGui::CollapsingHeader", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// if returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 755 + } + }, + { + "name": "ImGui_CollapsingHeaderBoolPtr", + "original_fully_qualified_name": "ImGui::CollapsingHeader", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_visible", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTreeNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiTreeNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// when 'p_visible != NULL': if '*p_visible==true' display an additional small close button on upper right of the header which will set the bool to false when clicked, if '*p_visible==false' don't display the header." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 756 + } + }, + { + "name": "ImGui_SetNextItemOpen", + "original_fully_qualified_name": "ImGui::SetNextItemOpen", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "is_open", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next TreeNode/CollapsingHeader open state." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 757 + } + }, + { + "name": "ImGui_SetNextItemStorageID", + "original_fully_qualified_name": "ImGui::SetNextItemStorageID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "storage_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set id to use for open/close storage (default to same as item id)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 758 + } + }, + { + "name": "ImGui_Selectable", + "original_fully_qualified_name": "ImGui::Selectable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Selectables", + "// - A selectable highlights when hovered, and can display another color when selected.", + "// - Neighbors selectable extend their highlight bounds in order to leave no gap between them. This is so a series of selected Selectable appear contiguous." + ], + "attached": "// Implied selected = false, flags = 0, size = ImVec2(0, 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 763 + } + }, + { + "name": "ImGui_SelectableEx", + "original_fully_qualified_name": "ImGui::Selectable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "selected", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSelectableFlags", + "description": { + "kind": "User", + "name": "ImGuiSelectableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// \"bool selected\" carry the selection state (read-only). Selectable() is clicked is returns true so you can modify your selection state. size.x==0.0: use remaining width, size.x>0.0: specify width. size.y==0.0: use label height, size.y>0.0: specify height" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 763 + } + }, + { + "name": "ImGui_SelectableBoolPtr", + "original_fully_qualified_name": "ImGui::Selectable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_selected", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSelectableFlags", + "description": { + "kind": "User", + "name": "ImGuiSelectableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied size = ImVec2(0, 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 764 + } + }, + { + "name": "ImGui_SelectableBoolPtrEx", + "original_fully_qualified_name": "ImGui::Selectable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_selected", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiSelectableFlags", + "description": { + "kind": "User", + "name": "ImGuiSelectableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// \"bool* p_selected\" point to the selection state (read-write), as a convenient helper." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 764 + } + }, + { + "name": "ImGui_BeginMultiSelect", + "original_fully_qualified_name": "ImGui::BeginMultiSelect", + "return_type": { + "declaration": "ImGuiMultiSelectIO*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectIO" + } + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiMultiSelectFlags", + "description": { + "kind": "User", + "name": "ImGuiMultiSelectFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Multi-selection system for Selectable(), Checkbox(), TreeNode() functions [BETA]", + "// - This enables standard multi-selection/range-selection idioms (CTRL+Mouse/Keyboard, SHIFT+Mouse/Keyboard, etc.) in a way that also allow a clipper to be used.", + "// - ImGuiSelectionUserData is often used to store your item index within the current view (but may store something else).", + "// - Read comments near ImGuiMultiSelectIO for instructions/details and see 'Demo->Widgets->Selection State & Multi-Select' for demo.", + "// - TreeNode() is technically supported but... using this correctly is more complicated. You need some sort of linear/random access to your tree,", + "// which is suited to advanced trees setups already implementing filters and clipper. We will work simplifying the current demo.", + "// - 'selection_size' and 'items_count' parameters are optional and used by a few features. If they are costly for you to compute, you may avoid them." + ], + "attached": "// Implied selection_size = -1, items_count = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 773 + } + }, + { + "name": "ImGui_BeginMultiSelectEx", + "original_fully_qualified_name": "ImGui::BeginMultiSelect", + "return_type": { + "declaration": "ImGuiMultiSelectIO*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectIO" + } + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiMultiSelectFlags", + "description": { + "kind": "User", + "name": "ImGuiMultiSelectFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "selection_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 773 + } + }, + { + "name": "ImGui_EndMultiSelect", + "original_fully_qualified_name": "ImGui::EndMultiSelect", + "return_type": { + "declaration": "ImGuiMultiSelectIO*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectIO" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 774 + } + }, + { + "name": "ImGui_SetNextItemSelectionUserData", + "original_fully_qualified_name": "ImGui::SetNextItemSelectionUserData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "selection_user_data", + "type": { + "declaration": "ImGuiSelectionUserData", + "description": { + "kind": "User", + "name": "ImGuiSelectionUserData" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 775 + } + }, + { + "name": "ImGui_IsItemToggledSelection", + "original_fully_qualified_name": "ImGui::IsItemToggledSelection", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Was the last item selection state toggled? Useful if you need the per-item information _before_ reaching EndMultiSelect(). We only returns toggle _event_ in order to handle clipping correctly." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 776 + } + }, + { + "name": "ImGui_BeginListBox", + "original_fully_qualified_name": "ImGui::BeginListBox", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: List Boxes", + "// - This is essentially a thin wrapper to using BeginChild/EndChild with the ImGuiChildFlags_FrameStyle flag for stylistic changes + displaying a label.", + "// - If you don't need a label you can probably simply use BeginChild() with the ImGuiChildFlags_FrameStyle flag for the same result.", + "// - You can submit contents and manage your selection state however you want it, by creating e.g. Selectable() or any other items.", + "// - The simplified/old ListBox() api are helpers over BeginListBox()/EndListBox() which are kept available for convenience purpose. This is analogous to how Combos are created.", + "// - Choose frame width: size.x > 0.0f: custom / size.x < 0.0f or -FLT_MIN: right-align / size.x = 0.0f (default): use current ItemWidth", + "// - Choose frame height: size.y > 0.0f: custom / size.y < 0.0f or -FLT_MIN: bottom-align / size.y = 0.0f (default): arbitrary default height which can fit ~7 items" + ], + "attached": "// open a framed scrolling region" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 785 + } + }, + { + "name": "ImGui_EndListBox", + "original_fully_qualified_name": "ImGui::EndListBox", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndListBox() if BeginListBox() returned true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 786 + } + }, + { + "name": "ImGui_ListBox", + "original_fully_qualified_name": "ImGui::ListBox", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items", + "type": { + "declaration": "const char*const[]", + "description": { + "kind": "Array", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + }, + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": true, + "is_varargs": false, + "array_bounds": "", + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "height_in_items", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 787 + } + }, + { + "name": "ImGui_ListBoxCallback", + "original_fully_qualified_name": "ImGui::ListBox", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "getter", + "type": { + "declaration": "const char* (*getter)(void* user_data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied height_in_items = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 788 + } + }, + { + "name": "ImGui_ListBoxCallbackEx", + "original_fully_qualified_name": "ImGui::ListBox", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "getter", + "type": { + "declaration": "const char* (*getter)(void* user_data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "height_in_items", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 788 + } + }, + { + "name": "ImGui_PlotLines", + "original_fully_qualified_name": "ImGui::PlotLines", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Data Plotting", + "// - Consider using ImPlot (https://github.com/epezent/implot) which is much better!" + ], + "attached": "// Implied values_offset = 0, overlay_text = NULL, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size = ImVec2(0, 0), stride = sizeof(float)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 792 + } + }, + { + "name": "ImGui_PlotLinesEx", + "original_fully_qualified_name": "ImGui::PlotLines", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_offset", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "overlay_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "scale_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "scale_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "graph_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "stride", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "sizeof(float)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 792 + } + }, + { + "name": "ImGui_PlotLinesCallback", + "original_fully_qualified_name": "ImGui::PlotLines", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_getter", + "type": { + "declaration": "float (*values_getter)(void* data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "values_getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "float" + }, + "parameters": [ + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied values_offset = 0, overlay_text = NULL, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size = ImVec2(0, 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 793 + } + }, + { + "name": "ImGui_PlotLinesCallbackEx", + "original_fully_qualified_name": "ImGui::PlotLines", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_getter", + "type": { + "declaration": "float (*values_getter)(void* data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "values_getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "float" + }, + "parameters": [ + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_offset", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "overlay_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "scale_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "scale_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "graph_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 793 + } + }, + { + "name": "ImGui_PlotHistogram", + "original_fully_qualified_name": "ImGui::PlotHistogram", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied values_offset = 0, overlay_text = NULL, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size = ImVec2(0, 0), stride = sizeof(float)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 794 + } + }, + { + "name": "ImGui_PlotHistogramEx", + "original_fully_qualified_name": "ImGui::PlotHistogram", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values", + "type": { + "declaration": "const float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_offset", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "overlay_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "scale_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "scale_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "graph_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "stride", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "sizeof(float)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 794 + } + }, + { + "name": "ImGui_PlotHistogramCallback", + "original_fully_qualified_name": "ImGui::PlotHistogram", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_getter", + "type": { + "declaration": "float (*values_getter)(void* data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "values_getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "float" + }, + "parameters": [ + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied values_offset = 0, overlay_text = NULL, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size = ImVec2(0, 0)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 795 + } + }, + { + "name": "ImGui_PlotHistogramCallbackEx", + "original_fully_qualified_name": "ImGui::PlotHistogram", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_getter", + "type": { + "declaration": "float (*values_getter)(void* data, int idx)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "values_getter", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "float" + }, + "parameters": [ + { + "kind": "Type", + "name": "data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "values_offset", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "overlay_text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "scale_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "scale_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "FLT_MAX", + "is_instance_pointer": false + }, + { + "name": "graph_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 795 + } + }, + { + "name": "ImGui_BeginMenuBar", + "original_fully_qualified_name": "ImGui::BeginMenuBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Widgets: Menus", + "// - Use BeginMenuBar() on a window ImGuiWindowFlags_MenuBar to append to its menu bar.", + "// - Use BeginMainMenuBar() to create a menu bar at the top of the screen and append to it.", + "// - Use BeginMenu() to create a menu. You can call BeginMenu() multiple time with the same identifier to append more items to it.", + "// - Not that MenuItem() keyboardshortcuts are displayed as a convenience but _not processed_ by Dear ImGui at the moment." + ], + "attached": "// append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set on parent window)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 809 + } + }, + { + "name": "ImGui_EndMenuBar", + "original_fully_qualified_name": "ImGui::EndMenuBar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndMenuBar() if BeginMenuBar() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 810 + } + }, + { + "name": "ImGui_BeginMainMenuBar", + "original_fully_qualified_name": "ImGui::BeginMainMenuBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create and append to a full screen menu-bar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 811 + } + }, + { + "name": "ImGui_EndMainMenuBar", + "original_fully_qualified_name": "ImGui::EndMainMenuBar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndMainMenuBar() if BeginMainMenuBar() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 812 + } + }, + { + "name": "ImGui_BeginMenu", + "original_fully_qualified_name": "ImGui::BeginMenu", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied enabled = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 813 + } + }, + { + "name": "ImGui_BeginMenuEx", + "original_fully_qualified_name": "ImGui::BeginMenu", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "enabled", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create a sub-menu entry. only call EndMenu() if this returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 813 + } + }, + { + "name": "ImGui_EndMenu", + "original_fully_qualified_name": "ImGui::EndMenu", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndMenu() if BeginMenu() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 814 + } + }, + { + "name": "ImGui_MenuItem", + "original_fully_qualified_name": "ImGui::MenuItem", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied shortcut = NULL, selected = false, enabled = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 815 + } + }, + { + "name": "ImGui_MenuItemEx", + "original_fully_qualified_name": "ImGui::MenuItem", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "shortcut", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "selected", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + }, + { + "name": "enabled", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return true when activated." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 815 + } + }, + { + "name": "ImGui_MenuItemBoolPtr", + "original_fully_qualified_name": "ImGui::MenuItem", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "shortcut", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_selected", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "enabled", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return true when activated + toggle (*p_selected) if p_selected != NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 816 + } + }, + { + "name": "ImGui_BeginTooltip", + "original_fully_qualified_name": "ImGui::BeginTooltip", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tooltips", + "// - Tooltips are windows following the mouse. They do not take focus away.", + "// - A tooltip window can contain items of any types.", + "// - SetTooltip() is more or less a shortcut for the 'if (BeginTooltip()) { Text(...); EndTooltip(); }' idiom (with a subtlety that it discard any previously submitted tooltip)" + ], + "attached": "// begin/append a tooltip window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 822 + } + }, + { + "name": "ImGui_EndTooltip", + "original_fully_qualified_name": "ImGui::EndTooltip", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndTooltip() if BeginTooltip()/BeginItemTooltip() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 823 + } + }, + { + "name": "ImGui_SetTooltip", + "original_fully_qualified_name": "ImGui::SetTooltip", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set a text-only tooltip. Often used after a ImGui::IsItemHovered() check. Override any previous call to SetTooltip()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 824 + } + }, + { + "name": "ImGui_SetTooltipV", + "original_fully_qualified_name": "ImGui::SetTooltipV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 825 + } + }, + { + "name": "ImGui_BeginItemTooltip", + "original_fully_qualified_name": "ImGui::BeginItemTooltip", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tooltips: helpers for showing a tooltip when hovering an item", + "// - BeginItemTooltip() is a shortcut for the 'if (IsItemHovered(ImGuiHoveredFlags_ForTooltip) && BeginTooltip())' idiom.", + "// - SetItemTooltip() is a shortcut for the 'if (IsItemHovered(ImGuiHoveredFlags_ForTooltip)) { SetTooltip(...); }' idiom.", + "// - Where 'ImGuiHoveredFlags_ForTooltip' itself is a shortcut to use 'style.HoverFlagsForTooltipMouse' or 'style.HoverFlagsForTooltipNav' depending on active input type. For mouse it defaults to 'ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayShort'." + ], + "attached": "// begin/append a tooltip window if preceding item was hovered." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 831 + } + }, + { + "name": "ImGui_SetItemTooltip", + "original_fully_qualified_name": "ImGui::SetItemTooltip", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set a text-only tooltip if preceding item was hovered. override any previous call to SetTooltip()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 832 + } + }, + { + "name": "ImGui_SetItemTooltipV", + "original_fully_qualified_name": "ImGui::SetItemTooltipV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 833 + } + }, + { + "name": "ImGui_BeginPopup", + "original_fully_qualified_name": "ImGui::BeginPopup", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Popups, Modals", + "// - They block normal mouse hovering detection (and therefore most mouse interactions) behind them.", + "// - If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.", + "// - Their visibility state (~bool) is held internally instead of being held by the programmer as we are used to with regular Begin*() calls.", + "// - The 3 properties above are related: we need to retain popup visibility state in the library because popups may be closed as any time.", + "// - You can bypass the hovering restriction by using ImGuiHoveredFlags_AllowWhenBlockedByPopup when calling IsItemHovered() or IsWindowHovered().", + "// - IMPORTANT: Popup identifiers are relative to the current ID stack, so OpenPopup and BeginPopup generally needs to be at the same level of the stack.", + "// This is sometimes leading to confusing mistakes. May rework this in the future.", + "// - BeginPopup(): query popup state, if open start appending into the window. Call EndPopup() afterwards if returned true. ImGuiWindowFlags are forwarded to the window.", + "// - BeginPopupModal(): block every interaction behind the window, cannot be closed by user, add a dimming background, has a title bar." + ], + "attached": "// return true if the popup is open, and you can start outputting to it." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 845 + } + }, + { + "name": "ImGui_BeginPopupModal", + "original_fully_qualified_name": "ImGui::BeginPopupModal", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "name", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return true if the modal is open, and you can start outputting to it." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 846 + } + }, + { + "name": "ImGui_EndPopup", + "original_fully_qualified_name": "ImGui::EndPopup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndPopup() if BeginPopupXXX() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 847 + } + }, + { + "name": "ImGui_OpenPopup", + "original_fully_qualified_name": "ImGui::OpenPopup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Popups: open/close functions", + "// - OpenPopup(): set popup state to open. ImGuiPopupFlags are available for opening options.", + "// - If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.", + "// - CloseCurrentPopup(): use inside the BeginPopup()/EndPopup() scope to close manually.", + "// - CloseCurrentPopup() is called by default by Selectable()/MenuItem() when activated (FIXME: need some options).", + "// - Use ImGuiPopupFlags_NoOpenOverExistingPopup to avoid opening a popup if there's already one at the same level. This is equivalent to e.g. testing for !IsAnyPopupOpen() prior to OpenPopup().", + "// - Use IsWindowAppearing() after BeginPopup() to tell if a window just opened.", + "// - IMPORTANT: Notice that for OpenPopupOnItemClick() we exceptionally default flags to 1 (== ImGuiPopupFlags_MouseButtonRight) for backward compatibility with older API taking 'int mouse_button = 1' parameter" + ], + "attached": "// call to mark popup as open (don't call every frame!)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 857 + } + }, + { + "name": "ImGui_OpenPopupID", + "original_fully_qualified_name": "ImGui::OpenPopup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// id overload to facilitate calling from nested stacks" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 858 + } + }, + { + "name": "ImGui_OpenPopupOnItemClick", + "original_fully_qualified_name": "ImGui::OpenPopupOnItemClick", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// helper to open popup when clicked on last item. Default to ImGuiPopupFlags_MouseButtonRight == 1. (note: actually triggers on the mouse _released_ event to be consistent with popup behaviors)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 859 + } + }, + { + "name": "ImGui_CloseCurrentPopup", + "original_fully_qualified_name": "ImGui::CloseCurrentPopup", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// manually close the popup we have begin-ed into." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 860 + } + }, + { + "name": "ImGui_BeginPopupContextItem", + "original_fully_qualified_name": "ImGui::BeginPopupContextItem", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Popups: open+begin combined functions helpers", + "// - Helpers to do OpenPopup+BeginPopup where the Open action is triggered by e.g. hovering an item and right-clicking.", + "// - They are convenient to easily create context menus, hence the name.", + "// - IMPORTANT: Notice that BeginPopupContextXXX takes ImGuiPopupFlags just like OpenPopup() and unlike BeginPopup(). For full consistency, we may add ImGuiWindowFlags to the BeginPopupContextXXX functions in the future.", + "// - IMPORTANT: Notice that we exceptionally default their flags to 1 (== ImGuiPopupFlags_MouseButtonRight) for backward compatibility with older API taking 'int mouse_button = 1' parameter, so if you add other flags remember to re-add the ImGuiPopupFlags_MouseButtonRight." + ], + "attached": "// Implied str_id = NULL, popup_flags = 1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 867 + } + }, + { + "name": "ImGui_BeginPopupContextItemEx", + "original_fully_qualified_name": "ImGui::BeginPopupContextItem", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// open+begin popup when clicked on last item. Use str_id==NULL to associate the popup to previous item. If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 867 + } + }, + { + "name": "ImGui_BeginPopupContextWindow", + "original_fully_qualified_name": "ImGui::BeginPopupContextWindow", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied str_id = NULL, popup_flags = 1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 868 + } + }, + { + "name": "ImGui_BeginPopupContextWindowEx", + "original_fully_qualified_name": "ImGui::BeginPopupContextWindow", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// open+begin popup when clicked on current window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 868 + } + }, + { + "name": "ImGui_BeginPopupContextVoid", + "original_fully_qualified_name": "ImGui::BeginPopupContextVoid", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied str_id = NULL, popup_flags = 1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 869 + } + }, + { + "name": "ImGui_BeginPopupContextVoidEx", + "original_fully_qualified_name": "ImGui::BeginPopupContextVoid", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "popup_flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// open+begin popup when clicked in void (where there are no windows)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 869 + } + }, + { + "name": "ImGui_IsPopupOpen", + "original_fully_qualified_name": "ImGui::IsPopupOpen", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiPopupFlags", + "description": { + "kind": "User", + "name": "ImGuiPopupFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Popups: query functions", + "// - IsPopupOpen(): return true if the popup is open at the current BeginPopup() level of the popup stack.", + "// - IsPopupOpen() with ImGuiPopupFlags_AnyPopupId: return true if any popup is open at the current BeginPopup() level of the popup stack.", + "// - IsPopupOpen() with ImGuiPopupFlags_AnyPopupId + ImGuiPopupFlags_AnyPopupLevel: return true if any popup is open." + ], + "attached": "// return true if the popup is open." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 875 + } + }, + { + "name": "ImGui_BeginTable", + "original_fully_qualified_name": "ImGui::BeginTable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "columns", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tables", + "// - Full-featured replacement for old Columns API.", + "// - See Demo->Tables for demo code. See top of imgui_tables.cpp for general commentary.", + "// - See ImGuiTableFlags_ and ImGuiTableColumnFlags_ enums for a description of available flags.", + "// The typical call flow is:", + "// - 1. Call BeginTable(), early out if returning false.", + "// - 2. Optionally call TableSetupColumn() to submit column name/flags/defaults.", + "// - 3. Optionally call TableSetupScrollFreeze() to request scroll freezing of columns/rows.", + "// - 4. Optionally call TableHeadersRow() to submit a header row. Names are pulled from TableSetupColumn() data.", + "// - 5. Populate contents:", + "// - In most situations you can use TableNextRow() + TableSetColumnIndex(N) to start appending into a column.", + "// - If you are using tables as a sort of grid, where every column is holding the same type of contents,", + "// you may prefer using TableNextColumn() instead of TableNextRow() + TableSetColumnIndex().", + "// TableNextColumn() will automatically wrap-around into the next row if needed.", + "// - IMPORTANT: Comparatively to the old Columns() API, we need to call TableNextColumn() for the first column!", + "// - Summary of possible call flow:", + "// - TableNextRow() -> TableSetColumnIndex(0) -> Text(\"Hello 0\") -> TableSetColumnIndex(1) -> Text(\"Hello 1\") // OK", + "// - TableNextRow() -> TableNextColumn() -> Text(\"Hello 0\") -> TableNextColumn() -> Text(\"Hello 1\") // OK", + "// - TableNextColumn() -> Text(\"Hello 0\") -> TableNextColumn() -> Text(\"Hello 1\") // OK: TableNextColumn() automatically gets to next row!", + "// - TableNextRow() -> Text(\"Hello 0\") // Not OK! Missing TableSetColumnIndex() or TableNextColumn()! Text will not appear!", + "// - 5. Call EndTable()" + ], + "attached": "// Implied outer_size = ImVec2(0.0f, 0.0f), inner_width = 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 898 + } + }, + { + "name": "ImGui_BeginTableEx", + "original_fully_qualified_name": "ImGui::BeginTable", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "columns", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTableFlags", + "description": { + "kind": "User", + "name": "ImGuiTableFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "outer_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0.0f, 0.0f)", + "is_instance_pointer": false + }, + { + "name": "inner_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 898 + } + }, + { + "name": "ImGui_EndTable", + "original_fully_qualified_name": "ImGui::EndTable", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndTable() if BeginTable() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 899 + } + }, + { + "name": "ImGui_TableNextRow", + "original_fully_qualified_name": "ImGui::TableNextRow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied row_flags = 0, min_row_height = 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 900 + } + }, + { + "name": "ImGui_TableNextRowEx", + "original_fully_qualified_name": "ImGui::TableNextRow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "row_flags", + "type": { + "declaration": "ImGuiTableRowFlags", + "description": { + "kind": "User", + "name": "ImGuiTableRowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "min_row_height", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// append into the first cell of a new row." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 900 + } + }, + { + "name": "ImGui_TableNextColumn", + "original_fully_qualified_name": "ImGui::TableNextColumn", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// append into the next column (or first column of next row if currently in last column). Return true when column is visible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 901 + } + }, + { + "name": "ImGui_TableSetColumnIndex", + "original_fully_qualified_name": "ImGui::TableSetColumnIndex", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// append into the specified column. Return true when column is visible." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 902 + } + }, + { + "name": "ImGui_TableSetupColumn", + "original_fully_qualified_name": "ImGui::TableSetupColumn", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTableColumnFlags", + "description": { + "kind": "User", + "name": "ImGuiTableColumnFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tables: Headers & Columns declaration", + "// - Use TableSetupColumn() to specify label, resizing policy, default width/weight, id, various other flags etc.", + "// - Use TableHeadersRow() to create a header row and automatically submit a TableHeader() for each column.", + "// Headers are required to perform: reordering, sorting, and opening the context menu.", + "// The context menu can also be made available in columns body using ImGuiTableFlags_ContextMenuInBody.", + "// - You may manually submit headers using TableNextRow() + TableHeader() calls, but this is only useful in", + "// some advanced use cases (e.g. adding custom widgets in header row).", + "// - Use TableSetupScrollFreeze() to lock columns/rows so they stay visible when scrolled." + ], + "attached": "// Implied init_width_or_weight = 0.0f, user_id = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 912 + } + }, + { + "name": "ImGui_TableSetupColumnEx", + "original_fully_qualified_name": "ImGui::TableSetupColumn", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTableColumnFlags", + "description": { + "kind": "User", + "name": "ImGuiTableColumnFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "init_width_or_weight", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "user_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 912 + } + }, + { + "name": "ImGui_TableSetupScrollFreeze", + "original_fully_qualified_name": "ImGui::TableSetupScrollFreeze", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "cols", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rows", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// lock columns/rows so they stay visible when scrolled." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 913 + } + }, + { + "name": "ImGui_TableHeader", + "original_fully_qualified_name": "ImGui::TableHeader", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// submit one header cell manually (rarely used)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 914 + } + }, + { + "name": "ImGui_TableHeadersRow", + "original_fully_qualified_name": "ImGui::TableHeadersRow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// submit a row with headers cells based on data provided to TableSetupColumn() + submit context menu" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 915 + } + }, + { + "name": "ImGui_TableAngledHeadersRow", + "original_fully_qualified_name": "ImGui::TableAngledHeadersRow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// submit a row with angled headers for every column with the ImGuiTableColumnFlags_AngledHeader flag. MUST BE FIRST ROW." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 916 + } + }, + { + "name": "ImGui_TableGetSortSpecs", + "original_fully_qualified_name": "ImGui::TableGetSortSpecs", + "return_type": { + "declaration": "ImGuiTableSortSpecs*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiTableSortSpecs" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tables: Sorting & Miscellaneous functions", + "// - Sorting: call TableGetSortSpecs() to retrieve latest sort specs for the table. NULL when not sorting.", + "// When 'sort_specs->SpecsDirty == true' you should sort your data. It will be true when sorting specs have", + "// changed since last call, or the first time. Make sure to set 'SpecsDirty = false' after sorting,", + "// else you may wastefully sort your data every frame!", + "// - Functions args 'int column_n' treat the default value of -1 as the same as passing the current column index." + ], + "attached": "// get latest sort specs for the table (NULL if not sorting). Lifetime: don't hold on this pointer over multiple frames or past any subsequent call to BeginTable()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 924 + } + }, + { + "name": "ImGui_TableGetColumnCount", + "original_fully_qualified_name": "ImGui::TableGetColumnCount", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return number of columns (value passed to BeginTable)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 925 + } + }, + { + "name": "ImGui_TableGetColumnIndex", + "original_fully_qualified_name": "ImGui::TableGetColumnIndex", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return current column index." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 926 + } + }, + { + "name": "ImGui_TableGetRowIndex", + "original_fully_qualified_name": "ImGui::TableGetRowIndex", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return current row index (header rows are accounted for)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 927 + } + }, + { + "name": "ImGui_TableGetColumnName", + "original_fully_qualified_name": "ImGui::TableGetColumnName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return \"\" if column didn't have a name declared by TableSetupColumn(). Pass -1 to use current column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 928 + } + }, + { + "name": "ImGui_TableGetColumnFlags", + "original_fully_qualified_name": "ImGui::TableGetColumnFlags", + "return_type": { + "declaration": "ImGuiTableColumnFlags", + "description": { + "kind": "User", + "name": "ImGuiTableColumnFlags" + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return column flags so you can query their Enabled/Visible/Sorted/Hovered status flags. Pass -1 to use current column." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 929 + } + }, + { + "name": "ImGui_TableSetColumnEnabled", + "original_fully_qualified_name": "ImGui::TableSetColumnEnabled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// change user accessible enabled/disabled state of a column. Set to false to hide the column. User can use the context menu to change this themselves (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 930 + } + }, + { + "name": "ImGui_TableGetHoveredColumn", + "original_fully_qualified_name": "ImGui::TableGetHoveredColumn", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return hovered column. return -1 when table is not hovered. return columns_count if the unused space at the right of visible columns is hovered. Can also use (TableGetColumnFlags() & ImGuiTableColumnFlags_IsHovered) instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 931 + } + }, + { + "name": "ImGui_TableSetBgColor", + "original_fully_qualified_name": "ImGui::TableSetBgColor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "target", + "type": { + "declaration": "ImGuiTableBgTarget", + "description": { + "kind": "User", + "name": "ImGuiTableBgTarget" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "color", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "column_n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// change the color of a cell, row, or column. See ImGuiTableBgTarget_ flags for details." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 932 + } + }, + { + "name": "ImGui_Columns", + "original_fully_qualified_name": "ImGui::Columns", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Legacy Columns API (prefer using Tables!)", + "// - You can also use SameLine(pos_x) to mimic simplified columns." + ], + "attached": "// Implied count = 1, id = NULL, borders = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 936 + } + }, + { + "name": "ImGui_ColumnsEx", + "original_fully_qualified_name": "ImGui::Columns", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1", + "is_instance_pointer": false + }, + { + "name": "id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "borders", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 936 + } + }, + { + "name": "ImGui_NextColumn", + "original_fully_qualified_name": "ImGui::NextColumn", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// next column, defaults to current row or next row if the current row is finished" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 937 + } + }, + { + "name": "ImGui_GetColumnIndex", + "original_fully_qualified_name": "ImGui::GetColumnIndex", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get current column index" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 938 + } + }, + { + "name": "ImGui_GetColumnWidth", + "original_fully_qualified_name": "ImGui::GetColumnWidth", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "column_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get column width (in pixels). pass -1 to use current column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 939 + } + }, + { + "name": "ImGui_SetColumnWidth", + "original_fully_qualified_name": "ImGui::SetColumnWidth", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set column width (in pixels). pass -1 to use current column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 940 + } + }, + { + "name": "ImGui_GetColumnOffset", + "original_fully_qualified_name": "ImGui::GetColumnOffset", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "column_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 941 + } + }, + { + "name": "ImGui_SetColumnOffset", + "original_fully_qualified_name": "ImGui::SetColumnOffset", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "column_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "offset_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 942 + } + }, + { + "name": "ImGui_GetColumnsCount", + "original_fully_qualified_name": "ImGui::GetColumnsCount", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 943 + } + }, + { + "name": "ImGui_BeginTabBar", + "original_fully_qualified_name": "ImGui::BeginTabBar", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "str_id", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabBarFlags", + "description": { + "kind": "User", + "name": "ImGuiTabBarFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Tab Bars, Tabs", + "// - Note: Tabs are automatically created by the docking system (when in 'docking' branch). Use this to create tab bars/tabs yourself." + ], + "attached": "// create and append into a TabBar" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 947 + } + }, + { + "name": "ImGui_EndTabBar", + "original_fully_qualified_name": "ImGui::EndTabBar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndTabBar() if BeginTabBar() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 948 + } + }, + { + "name": "ImGui_BeginTabItem", + "original_fully_qualified_name": "ImGui::BeginTabItem", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create a Tab. Returns true if the Tab is selected." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 949 + } + }, + { + "name": "ImGui_EndTabItem", + "original_fully_qualified_name": "ImGui::EndTabItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndTabItem() if BeginTabItem() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 950 + } + }, + { + "name": "ImGui_TabItemButton", + "original_fully_qualified_name": "ImGui::TabItemButton", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiTabItemFlags", + "description": { + "kind": "User", + "name": "ImGuiTabItemFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// create a Tab behaving like a button. return true when clicked. cannot be selected in the tab bar." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 951 + } + }, + { + "name": "ImGui_SetTabItemClosed", + "original_fully_qualified_name": "ImGui::SetTabItemClosed", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_or_docked_window_label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// notify TabBar or Docking system of a closed tab/window ahead (useful to reduce visual flicker on reorderable tab bars). For tab-bar: call after BeginTabBar() and before Tab submissions. Otherwise call with a window name." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 952 + } + }, + { + "name": "ImGui_DockSpace", + "original_fully_qualified_name": "ImGui::DockSpace", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "dockspace_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Docking", + "// [BETA API] Enable with io.ConfigFlags |= ImGuiConfigFlags_DockingEnable.", + "// Note: You can use most Docking facilities without calling any API. You DO NOT need to call DockSpace() to use Docking!", + "// - Drag from window title bar or their tab to dock/undock. Hold SHIFT to disable docking.", + "// - Drag from window menu button (upper-left button) to undock an entire node (all windows).", + "// - When io.ConfigDockingWithShift == true, you instead need to hold SHIFT to enable docking.", + "// About dockspaces:", + "// - Use DockSpaceOverViewport() to create a window covering the screen or a specific viewport + a dockspace inside it.", + "// This is often used with ImGuiDockNodeFlags_PassthruCentralNode to make it transparent.", + "// - Use DockSpace() to create an explicit dock node _within_ an existing window. See Docking demo for details.", + "// - Important: Dockspaces need to be submitted _before_ any window they can host. Submit it early in your frame!", + "// - Important: Dockspaces need to be kept alive if hidden, otherwise windows docked into it will be undocked.", + "// e.g. if you have multiple tabs with a dockspace inside each tab: submit the non-visible dockspaces with ImGuiDockNodeFlags_KeepAliveOnly." + ], + "attached": "// Implied size = ImVec2(0, 0), flags = 0, window_class = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 967 + } + }, + { + "name": "ImGui_DockSpaceEx", + "original_fully_qualified_name": "ImGui::DockSpace", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "dockspace_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "window_class", + "type": { + "declaration": "const ImGuiWindowClass*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowClass", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 967 + } + }, + { + "name": "ImGui_DockSpaceOverViewport", + "original_fully_qualified_name": "ImGui::DockSpaceOverViewport", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied dockspace_id = 0, viewport = NULL, flags = 0, window_class = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 968 + } + }, + { + "name": "ImGui_DockSpaceOverViewportEx", + "original_fully_qualified_name": "ImGui::DockSpaceOverViewport", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "dockspace_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "viewport", + "type": { + "declaration": "const ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiDockNodeFlags", + "description": { + "kind": "User", + "name": "ImGuiDockNodeFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "window_class", + "type": { + "declaration": "const ImGuiWindowClass*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowClass", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 968 + } + }, + { + "name": "ImGui_SetNextWindowDockID", + "original_fully_qualified_name": "ImGui::SetNextWindowDockID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "dock_id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window dock id" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 969 + } + }, + { + "name": "ImGui_SetNextWindowClass", + "original_fully_qualified_name": "ImGui::SetNextWindowClass", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "window_class", + "type": { + "declaration": "const ImGuiWindowClass*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiWindowClass", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set next window class (control docking compatibility + provide hints to platform backend via custom viewport flags and platform parent/child relationship)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 970 + } + }, + { + "name": "ImGui_GetWindowDockID", + "original_fully_qualified_name": "ImGui::GetWindowDockID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 971 + } + }, + { + "name": "ImGui_IsWindowDocked", + "original_fully_qualified_name": "ImGui::IsWindowDocked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is current window docked into another window?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 972 + } + }, + { + "name": "ImGui_LogToTTY", + "original_fully_qualified_name": "ImGui::LogToTTY", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "auto_open_depth", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Logging/Capture", + "// - All text output from the interface can be captured into tty/file/clipboard. By default, tree nodes are automatically opened during logging." + ], + "attached": "// start logging to tty (stdout)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 976 + } + }, + { + "name": "ImGui_LogToFile", + "original_fully_qualified_name": "ImGui::LogToFile", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "auto_open_depth", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + }, + { + "name": "filename", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// start logging to file" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 977 + } + }, + { + "name": "ImGui_LogToClipboard", + "original_fully_qualified_name": "ImGui::LogToClipboard", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "auto_open_depth", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// start logging to OS clipboard" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 978 + } + }, + { + "name": "ImGui_LogFinish", + "original_fully_qualified_name": "ImGui::LogFinish", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// stop logging (close file, etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 979 + } + }, + { + "name": "ImGui_LogButtons", + "original_fully_qualified_name": "ImGui::LogButtons", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// helper to display buttons for logging to tty/file/clipboard" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 980 + } + }, + { + "name": "ImGui_LogText", + "original_fully_qualified_name": "ImGui::LogText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// pass text data straight to log (without being displayed)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 981 + } + }, + { + "name": "ImGui_LogTextV", + "original_fully_qualified_name": "ImGui::LogTextV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 982 + } + }, + { + "name": "ImGui_BeginDragDropSource", + "original_fully_qualified_name": "ImGui::BeginDragDropSource", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiDragDropFlags", + "description": { + "kind": "User", + "name": "ImGuiDragDropFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Drag and Drop", + "// - On source items, call BeginDragDropSource(), if it returns true also call SetDragDropPayload() + EndDragDropSource().", + "// - On target candidates, call BeginDragDropTarget(), if it returns true also call AcceptDragDropPayload() + EndDragDropTarget().", + "// - If you stop calling BeginDragDropSource() the payload is preserved however it won't have a preview tooltip (we currently display a fallback \"...\" tooltip, see #1725)", + "// - An item can be both drag source and drop target." + ], + "attached": "// call after submitting an item which may be dragged. when this return true, you can call SetDragDropPayload() + EndDragDropSource()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 989 + } + }, + { + "name": "ImGui_SetDragDropPayload", + "original_fully_qualified_name": "ImGui::SetDragDropPayload", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "type", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "data", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cond", + "type": { + "declaration": "ImGuiCond", + "description": { + "kind": "User", + "name": "ImGuiCond" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types. Data is copied and held by imgui. Return true when payload has been accepted." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 990 + } + }, + { + "name": "ImGui_EndDragDropSource", + "original_fully_qualified_name": "ImGui::EndDragDropSource", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndDragDropSource() if BeginDragDropSource() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 991 + } + }, + { + "name": "ImGui_BeginDragDropTarget", + "original_fully_qualified_name": "ImGui::BeginDragDropTarget", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// call after submitting an item that may receive a payload. If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 992 + } + }, + { + "name": "ImGui_AcceptDragDropPayload", + "original_fully_qualified_name": "ImGui::AcceptDragDropPayload", + "return_type": { + "declaration": "const ImGuiPayload*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPayload", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "type", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiDragDropFlags", + "description": { + "kind": "User", + "name": "ImGuiDragDropFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// accept contents of a given type. If ImGuiDragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 993 + } + }, + { + "name": "ImGui_EndDragDropTarget", + "original_fully_qualified_name": "ImGui::EndDragDropTarget", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// only call EndDragDropTarget() if BeginDragDropTarget() returns true!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 994 + } + }, + { + "name": "ImGui_GetDragDropPayload", + "original_fully_qualified_name": "ImGui::GetDragDropPayload", + "return_type": { + "declaration": "const ImGuiPayload*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiPayload", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// peek directly into the current payload from anywhere. returns NULL when drag and drop is finished or inactive. use ImGuiPayload::IsDataType() to test for the payload type." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 995 + } + }, + { + "name": "ImGui_BeginDisabled", + "original_fully_qualified_name": "ImGui::BeginDisabled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "disabled", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Disabling [BETA API]", + "// - Disable all user interactions and dim items visuals (applying style.DisabledAlpha over current colors)", + "// - Those can be nested but it cannot be used to enable an already disabled section (a single BeginDisabled(true) in the stack is enough to keep everything disabled)", + "// - Tooltips windows by exception are opted out of disabling.", + "// - BeginDisabled(false)/EndDisabled() essentially does nothing but is provided to facilitate use of boolean expressions (as a micro-optimization: if you have tens of thousands of BeginDisabled(false)/EndDisabled() pairs, you might want to reformulate your code to avoid making those calls)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1002 + } + }, + { + "name": "ImGui_EndDisabled", + "original_fully_qualified_name": "ImGui::EndDisabled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1003 + } + }, + { + "name": "ImGui_PushClipRect", + "original_fully_qualified_name": "ImGui::PushClipRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "clip_rect_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clip_rect_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "intersect_with_current_clip_rect", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Clipping", + "// - Mouse hovering is affected by ImGui::PushClipRect() calls, unlike direct calls to ImDrawList::PushClipRect() which are render only." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1007 + } + }, + { + "name": "ImGui_PopClipRect", + "original_fully_qualified_name": "ImGui::PopClipRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1008 + } + }, + { + "name": "ImGui_SetItemDefaultFocus", + "original_fully_qualified_name": "ImGui::SetItemDefaultFocus", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Focus, Activation" + ], + "attached": "// make last item the default focused item of a newly appearing window." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1011 + } + }, + { + "name": "ImGui_SetKeyboardFocusHere", + "original_fully_qualified_name": "ImGui::SetKeyboardFocusHere", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied offset = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1012 + } + }, + { + "name": "ImGui_SetKeyboardFocusHereEx", + "original_fully_qualified_name": "ImGui::SetKeyboardFocusHere", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "offset", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1012 + } + }, + { + "name": "ImGui_SetNavCursorVisible", + "original_fully_qualified_name": "ImGui::SetNavCursorVisible", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "visible", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Keyboard/Gamepad Navigation" + ], + "attached": "// alter visibility of keyboard/gamepad cursor. by default: show when using an arrow key, hide when clicking with mouse." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1015 + } + }, + { + "name": "ImGui_SetNextItemAllowOverlap", + "original_fully_qualified_name": "ImGui::SetNextItemAllowOverlap", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Overlapping mode" + ], + "attached": "// allow next item to be overlapped by a subsequent item. Useful with invisible buttons, selectable, treenode covering an area where subsequent items may need to be added. Note that both Selectable() and TreeNode() have dedicated flags doing this." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1018 + } + }, + { + "name": "ImGui_IsItemHovered", + "original_fully_qualified_name": "ImGui::IsItemHovered", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "flags", + "type": { + "declaration": "ImGuiHoveredFlags", + "description": { + "kind": "User", + "name": "ImGuiHoveredFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Item/Widgets Utilities and Query Functions", + "// - Most of the functions are referring to the previous Item that has been submitted.", + "// - See Demo Window under \"Widgets->Querying Status\" for an interactive visualization of most of those functions." + ], + "attached": "// is the last item hovered? (and usable, aka not blocked by a popup, etc.). See ImGuiHoveredFlags for more options." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1023 + } + }, + { + "name": "ImGui_IsItemActive", + "original_fully_qualified_name": "ImGui::IsItemActive", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is the last item active? (e.g. button being held, text field being edited. This will continuously return true while holding mouse button on an item. Items that don't interact will always return false)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1024 + } + }, + { + "name": "ImGui_IsItemFocused", + "original_fully_qualified_name": "ImGui::IsItemFocused", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is the last item focused for keyboard/gamepad navigation?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1025 + } + }, + { + "name": "ImGui_IsItemClicked", + "original_fully_qualified_name": "ImGui::IsItemClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied mouse_button = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1026 + } + }, + { + "name": "ImGui_IsItemClickedEx", + "original_fully_qualified_name": "ImGui::IsItemClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "mouse_button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is the last item hovered and mouse clicked on? (**) == IsMouseClicked(mouse_button) && IsItemHovered()Important. (**) this is NOT equivalent to the behavior of e.g. Button(). Read comments in function definition." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1026 + } + }, + { + "name": "ImGui_IsItemVisible", + "original_fully_qualified_name": "ImGui::IsItemVisible", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is the last item visible? (items may be out of sight because of clipping/scrolling)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1027 + } + }, + { + "name": "ImGui_IsItemEdited", + "original_fully_qualified_name": "ImGui::IsItemEdited", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// did the last item modify its underlying value this frame? or was pressed? This is generally the same as the \"bool\" return value of many widgets." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1028 + } + }, + { + "name": "ImGui_IsItemActivated", + "original_fully_qualified_name": "ImGui::IsItemActivated", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// was the last item just made active (item was previously inactive)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1029 + } + }, + { + "name": "ImGui_IsItemDeactivated", + "original_fully_qualified_name": "ImGui::IsItemDeactivated", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// was the last item just made inactive (item was previously active). Useful for Undo/Redo patterns with widgets that require continuous editing." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1030 + } + }, + { + "name": "ImGui_IsItemDeactivatedAfterEdit", + "original_fully_qualified_name": "ImGui::IsItemDeactivatedAfterEdit", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// was the last item just made inactive and made a value change when it was active? (e.g. Slider/Drag moved). Useful for Undo/Redo patterns with widgets that require continuous editing. Note that you may get false positives (some widgets such as Combo()/ListBox()/Selectable() will return true even when clicking an already selected item)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1031 + } + }, + { + "name": "ImGui_IsItemToggledOpen", + "original_fully_qualified_name": "ImGui::IsItemToggledOpen", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// was the last item open state toggled? set by TreeNode()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1032 + } + }, + { + "name": "ImGui_IsAnyItemHovered", + "original_fully_qualified_name": "ImGui::IsAnyItemHovered", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is any item hovered?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1033 + } + }, + { + "name": "ImGui_IsAnyItemActive", + "original_fully_qualified_name": "ImGui::IsAnyItemActive", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is any item active?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1034 + } + }, + { + "name": "ImGui_IsAnyItemFocused", + "original_fully_qualified_name": "ImGui::IsAnyItemFocused", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is any item focused?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1035 + } + }, + { + "name": "ImGui_GetItemID", + "original_fully_qualified_name": "ImGui::GetItemID", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get ID of last item (~~ often same ImGui::GetID(label) beforehand)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1036 + } + }, + { + "name": "ImGui_GetItemRectMin", + "original_fully_qualified_name": "ImGui::GetItemRectMin", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get upper-left bounding rectangle of the last item (screen space)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1037 + } + }, + { + "name": "ImGui_GetItemRectMax", + "original_fully_qualified_name": "ImGui::GetItemRectMax", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get lower-right bounding rectangle of the last item (screen space)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1038 + } + }, + { + "name": "ImGui_GetItemRectSize", + "original_fully_qualified_name": "ImGui::GetItemRectSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get size of last item" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1039 + } + }, + { + "name": "ImGui_GetMainViewport", + "original_fully_qualified_name": "ImGui::GetMainViewport", + "return_type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Viewports", + "// - Currently represents the Platform Window created by the application which is hosting our Dear ImGui windows.", + "// - In 'docking' branch with multi-viewport enabled, we extend this concept to have multiple active viewports.", + "// - In the future we will extend this concept further to also represent Platform Monitor and support a \"no main platform window\" operation mode." + ], + "attached": "// return primary/default viewport. This can never be NULL." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1045 + } + }, + { + "name": "ImGui_GetBackgroundDrawList", + "original_fully_qualified_name": "ImGui::GetBackgroundDrawList", + "return_type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Background/Foreground Draw Lists" + ], + "attached": "// Implied viewport = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1048 + } + }, + { + "name": "ImGui_GetBackgroundDrawListEx", + "original_fully_qualified_name": "ImGui::GetBackgroundDrawList", + "return_type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "arguments": [ + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get background draw list for the given viewport or viewport associated to the current window. this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1048 + } + }, + { + "name": "ImGui_GetForegroundDrawList", + "original_fully_qualified_name": "ImGui::GetForegroundDrawList", + "return_type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied viewport = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1049 + } + }, + { + "name": "ImGui_GetForegroundDrawListEx", + "original_fully_qualified_name": "ImGui::GetForegroundDrawList", + "return_type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "arguments": [ + { + "name": "viewport", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get foreground draw list for the given viewport or viewport associated to the current window. this draw list will be the top-most rendered one. Useful to quickly draw shapes/text over dear imgui contents." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1049 + } + }, + { + "name": "ImGui_IsRectVisibleBySize", + "original_fully_qualified_name": "ImGui::IsRectVisible", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Miscellaneous Utilities" + ], + "attached": "// test if rectangle (of given size, starting from cursor position) is visible / not clipped." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1052 + } + }, + { + "name": "ImGui_IsRectVisible", + "original_fully_qualified_name": "ImGui::IsRectVisible", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "rect_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rect_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1053 + } + }, + { + "name": "ImGui_GetTime", + "original_fully_qualified_name": "ImGui::GetTime", + "return_type": { + "declaration": "double", + "description": { + "kind": "Builtin", + "builtin_type": "double" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get global imgui time. incremented by io.DeltaTime every frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1054 + } + }, + { + "name": "ImGui_GetFrameCount", + "original_fully_qualified_name": "ImGui::GetFrameCount", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get global imgui frame count. incremented by 1 every frame." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1055 + } + }, + { + "name": "ImGui_GetDrawListSharedData", + "original_fully_qualified_name": "ImGui::GetDrawListSharedData", + "return_type": { + "declaration": "ImDrawListSharedData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawListSharedData" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// you may use this when creating your own ImDrawList instances." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1056 + } + }, + { + "name": "ImGui_GetStyleColorName", + "original_fully_qualified_name": "ImGui::GetStyleColorName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get a string corresponding to the enum value (for display, saving, etc.)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1057 + } + }, + { + "name": "ImGui_SetStateStorage", + "original_fully_qualified_name": "ImGui::SetStateStorage", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "storage", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// replace current window storage with our own (if you want to manipulate it yourself, typically clear subsection of it)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1058 + } + }, + { + "name": "ImGui_GetStateStorage", + "original_fully_qualified_name": "ImGui::GetStateStorage", + "return_type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1059 + } + }, + { + "name": "ImGui_CalcTextSize", + "original_fully_qualified_name": "ImGui::CalcTextSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Text Utilities" + ], + "attached": "// Implied text_end = NULL, hide_text_after_double_hash = false, wrap_width = -1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1062 + } + }, + { + "name": "ImGui_CalcTextSizeEx", + "original_fully_qualified_name": "ImGui::CalcTextSize", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "hide_text_after_double_hash", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1062 + } + }, + { + "name": "ImGui_ColorConvertU32ToFloat4", + "original_fully_qualified_name": "ImGui::ColorConvertU32ToFloat4", + "return_type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "arguments": [ + { + "name": "in", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Color Utilities" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1065 + } + }, + { + "name": "ImGui_ColorConvertFloat4ToU32", + "original_fully_qualified_name": "ImGui::ColorConvertFloat4ToU32", + "return_type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "arguments": [ + { + "name": "in", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1066 + } + }, + { + "name": "ImGui_ColorConvertRGBtoHSV", + "original_fully_qualified_name": "ImGui::ColorConvertRGBtoHSV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "r", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "g", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_h", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_s", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_v", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1067 + } + }, + { + "name": "ImGui_ColorConvertHSVtoRGB", + "original_fully_qualified_name": "ImGui::ColorConvertHSVtoRGB", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "h", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "s", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_r", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_g", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_b", + "type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1068 + } + }, + { + "name": "ImGui_IsKeyDown", + "original_fully_qualified_name": "ImGui::IsKeyDown", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Inputs Utilities: Keyboard/Mouse/Gamepad", + "// - the ImGuiKey enum contains all possible keyboard, mouse and gamepad inputs (e.g. ImGuiKey_A, ImGuiKey_MouseLeft, ImGuiKey_GamepadDpadUp...).", + "// - (legacy: before v1.87, we used ImGuiKey to carry native/user indices as defined by each backends. This was obsoleted in 1.87 (2022-02) and completely removed in 1.91.5 (2024-11). See https://github.com/ocornut/imgui/issues/4921)", + "// - (legacy: any use of ImGuiKey will assert when key < 512 to detect passing legacy native/user indices)" + ], + "attached": "// is key being held." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1074 + } + }, + { + "name": "ImGui_IsKeyPressed", + "original_fully_qualified_name": "ImGui::IsKeyPressed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied repeat = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1075 + } + }, + { + "name": "ImGui_IsKeyPressedEx", + "original_fully_qualified_name": "ImGui::IsKeyPressed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "repeat", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// was key pressed (went from !Down to Down)? if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1075 + } + }, + { + "name": "ImGui_IsKeyReleased", + "original_fully_qualified_name": "ImGui::IsKeyReleased", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// was key released (went from Down to !Down)?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1076 + } + }, + { + "name": "ImGui_IsKeyChordPressed", + "original_fully_qualified_name": "ImGui::IsKeyChordPressed", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// was key chord (mods + key) pressed, e.g. you can pass 'ImGuiMod_Ctrl | ImGuiKey_S' as a key-chord. This doesn't do any routing or focus check, please consider using Shortcut() function instead." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1077 + } + }, + { + "name": "ImGui_GetKeyPressedAmount", + "original_fully_qualified_name": "ImGui::GetKeyPressedAmount", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "repeat_delay", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rate", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// uses provided repeat rate/delay. return a count, most often 0 or 1 but might be >1 if RepeatRate is small enough that DeltaTime > RepeatRate" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1078 + } + }, + { + "name": "ImGui_GetKeyName", + "original_fully_qualified_name": "ImGui::GetKeyName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [DEBUG] returns English name of the key. Those names are provided for debugging purpose and are not meant to be saved persistently nor compared." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1079 + } + }, + { + "name": "ImGui_SetNextFrameWantCaptureKeyboard", + "original_fully_qualified_name": "ImGui::SetNextFrameWantCaptureKeyboard", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "want_capture_keyboard", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Override io.WantCaptureKeyboard flag next frame (said flag is left for your application to handle, typically when true it instructs your app to ignore inputs). e.g. force capture keyboard when your widget is being hovered. This is equivalent to setting \"io.WantCaptureKeyboard = want_capture_keyboard\"; after the next NewFrame() call." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1080 + } + }, + { + "name": "ImGui_Shortcut", + "original_fully_qualified_name": "ImGui::Shortcut", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Inputs Utilities: Shortcut Testing & Routing [BETA]", + "// - ImGuiKeyChord = a ImGuiKey + optional ImGuiMod_Alt/ImGuiMod_Ctrl/ImGuiMod_Shift/ImGuiMod_Super.", + "// ImGuiKey_C // Accepted by functions taking ImGuiKey or ImGuiKeyChord arguments)", + "// ImGuiMod_Ctrl | ImGuiKey_C // Accepted by functions taking ImGuiKeyChord arguments)", + "// only ImGuiMod_XXX values are legal to combine with an ImGuiKey. You CANNOT combine two ImGuiKey values.", + "// - The general idea is that several callers may register interest in a shortcut, and only one owner gets it.", + "// Parent -> call Shortcut(Ctrl+S) // When Parent is focused, Parent gets the shortcut.", + "// Child1 -> call Shortcut(Ctrl+S) // When Child1 is focused, Child1 gets the shortcut (Child1 overrides Parent shortcuts)", + "// Child2 -> no call // When Child2 is focused, Parent gets the shortcut.", + "// The whole system is order independent, so if Child1 makes its calls before Parent, results will be identical.", + "// This is an important property as it facilitate working with foreign code or larger codebase.", + "// - To understand the difference:", + "// - IsKeyChordPressed() compares mods and call IsKeyPressed() -> function has no side-effect.", + "// - Shortcut() submits a route, routes are resolved, if it currently can be routed it calls IsKeyChordPressed() -> function has (desirable) side-effects as it can prevents another call from getting the route.", + "// - Visualize registered routes in 'Metrics/Debugger->Inputs'." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1097 + } + }, + { + "name": "ImGui_SetNextItemShortcut", + "original_fully_qualified_name": "ImGui::SetNextItemShortcut", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "key_chord", + "type": { + "declaration": "ImGuiKeyChord", + "description": { + "kind": "User", + "name": "ImGuiKeyChord" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImGuiInputFlags", + "description": { + "kind": "User", + "name": "ImGuiInputFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1098 + } + }, + { + "name": "ImGui_SetItemKeyOwner", + "original_fully_qualified_name": "ImGui::SetItemKeyOwner", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Inputs Utilities: Key/Input Ownership [BETA]", + "// - One common use case would be to allow your items to disable standard inputs behaviors such", + "// as Tab or Alt key handling, Mouse Wheel scrolling, etc.", + "// e.g. Button(...); SetItemKeyOwner(ImGuiKey_MouseWheelY); to make hovering/activating a button disable wheel for scrolling.", + "// - Reminder ImGuiKey enum include access to mouse buttons and gamepad, so key ownership can apply to them.", + "// - Many related features are still in imgui_internal.h. For instance, most IsKeyXXX()/IsMouseXXX() functions have an owner-id-aware version." + ], + "attached": "// Set key owner to last item ID if it is hovered or active. Equivalent to 'if (IsItemHovered() || IsItemActive()) { SetKeyOwner(key, GetItemID());'." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1106 + } + }, + { + "name": "ImGui_IsMouseDown", + "original_fully_qualified_name": "ImGui::IsMouseDown", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Inputs Utilities: Mouse", + "// - To refer to a mouse button, you may use named enums in your code e.g. ImGuiMouseButton_Left, ImGuiMouseButton_Right.", + "// - You can also use regular integer: it is forever guaranteed that 0=Left, 1=Right, 2=Middle.", + "// - Dragging operations are only reported after mouse has moved a certain distance away from the initial clicking position (see 'lock_threshold' and 'io.MouseDraggingThreshold')" + ], + "attached": "// is mouse button held?" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1112 + } + }, + { + "name": "ImGui_IsMouseClicked", + "original_fully_qualified_name": "ImGui::IsMouseClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied repeat = false" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1113 + } + }, + { + "name": "ImGui_IsMouseClickedEx", + "original_fully_qualified_name": "ImGui::IsMouseClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "repeat", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// did mouse button clicked? (went from !Down to Down). Same as GetMouseClickedCount() == 1." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1113 + } + }, + { + "name": "ImGui_IsMouseReleased", + "original_fully_qualified_name": "ImGui::IsMouseReleased", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// did mouse button released? (went from Down to !Down)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1114 + } + }, + { + "name": "ImGui_IsMouseDoubleClicked", + "original_fully_qualified_name": "ImGui::IsMouseDoubleClicked", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// did mouse button double-clicked? Same as GetMouseClickedCount() == 2. (note that a double-click will also report IsMouseClicked() == true)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1115 + } + }, + { + "name": "ImGui_IsMouseReleasedWithDelay", + "original_fully_qualified_name": "ImGui::IsMouseReleasedWithDelay", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "delay", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// delayed mouse release (use very sparingly!). Generally used with 'delay >= io.MouseDoubleClickTime' + combined with a 'io.MouseClickedLastCount==1' test. This is a very rarely used UI idiom, but some apps use this: e.g. MS Explorer single click on an icon to rename." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1116 + } + }, + { + "name": "ImGui_GetMouseClickedCount", + "original_fully_qualified_name": "ImGui::GetMouseClickedCount", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return the number of successive mouse-clicks at the time where a click happen (otherwise 0)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1117 + } + }, + { + "name": "ImGui_IsMouseHoveringRect", + "original_fully_qualified_name": "ImGui::IsMouseHoveringRect", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "r_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied clip = true" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1118 + } + }, + { + "name": "ImGui_IsMouseHoveringRectEx", + "original_fully_qualified_name": "ImGui::IsMouseHoveringRect", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "r_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "r_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clip", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "true", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is mouse hovering given bounding rect (in screen space). clipped by current clipping settings, but disregarding of other consideration of focus/window ordering/popup-block." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1118 + } + }, + { + "name": "ImGui_IsMousePosValid", + "original_fully_qualified_name": "ImGui::IsMousePosValid", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "mouse_pos", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// by convention we use (-FLT_MAX,-FLT_MAX) to denote that there is no mouse available" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1119 + } + }, + { + "name": "ImGui_IsAnyMouseDown", + "original_fully_qualified_name": "ImGui::IsAnyMouseDown", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// [WILL OBSOLETE] is any mouse button held? This was designed for backends, but prefer having backend maintain a mask of held mouse buttons, because upcoming input queue system will make this invalid." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1120 + } + }, + { + "name": "ImGui_GetMousePos", + "original_fully_qualified_name": "ImGui::GetMousePos", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1121 + } + }, + { + "name": "ImGui_GetMousePosOnOpeningCurrentPopup", + "original_fully_qualified_name": "ImGui::GetMousePosOnOpeningCurrentPopup", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// retrieve mouse position at the time of opening popup we have BeginPopup() into (helper to avoid user backing that value themselves)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1122 + } + }, + { + "name": "ImGui_IsMouseDragging", + "original_fully_qualified_name": "ImGui::IsMouseDragging", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "lock_threshold", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// is mouse dragging? (uses io.MouseDraggingThreshold if lock_threshold < 0.0f)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1123 + } + }, + { + "name": "ImGui_GetMouseDragDelta", + "original_fully_qualified_name": "ImGui::GetMouseDragDelta", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "lock_threshold", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return the delta from the initial clicking position while the mouse button is pressed or was just released. This is locked and return 0.0f until the mouse moves past a distance threshold at least once (uses io.MouseDraggingThreshold if lock_threshold < 0.0f)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1124 + } + }, + { + "name": "ImGui_ResetMouseDragDelta", + "original_fully_qualified_name": "ImGui::ResetMouseDragDelta", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied button = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1125 + } + }, + { + "name": "ImGui_ResetMouseDragDeltaEx", + "original_fully_qualified_name": "ImGui::ResetMouseDragDelta", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "button", + "type": { + "declaration": "ImGuiMouseButton", + "description": { + "kind": "User", + "name": "ImGuiMouseButton" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "//" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1125 + } + }, + { + "name": "ImGui_GetMouseCursor", + "original_fully_qualified_name": "ImGui::GetMouseCursor", + "return_type": { + "declaration": "ImGuiMouseCursor", + "description": { + "kind": "User", + "name": "ImGuiMouseCursor" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// get desired mouse cursor shape. Important: reset in ImGui::NewFrame(), this is updated during the frame. valid before Render(). If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1126 + } + }, + { + "name": "ImGui_SetMouseCursor", + "original_fully_qualified_name": "ImGui::SetMouseCursor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "cursor_type", + "type": { + "declaration": "ImGuiMouseCursor", + "description": { + "kind": "User", + "name": "ImGuiMouseCursor" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// set desired mouse cursor shape" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1127 + } + }, + { + "name": "ImGui_SetNextFrameWantCaptureMouse", + "original_fully_qualified_name": "ImGui::SetNextFrameWantCaptureMouse", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "want_capture_mouse", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Override io.WantCaptureMouse flag next frame (said flag is left for your application to handle, typical when true it instructs your app to ignore inputs). This is equivalent to setting \"io.WantCaptureMouse = want_capture_mouse;\" after the next NewFrame() call." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1128 + } + }, + { + "name": "ImGui_GetClipboardText", + "original_fully_qualified_name": "ImGui::GetClipboardText", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Clipboard Utilities", + "// - Also see the LogToClipboard() function to capture GUI into clipboard, or easily output text data to the clipboard." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1132 + } + }, + { + "name": "ImGui_SetClipboardText", + "original_fully_qualified_name": "ImGui::SetClipboardText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1133 + } + }, + { + "name": "ImGui_LoadIniSettingsFromDisk", + "original_fully_qualified_name": "ImGui::LoadIniSettingsFromDisk", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ini_filename", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Settings/.Ini Utilities", + "// - The disk functions are automatically called if io.IniFilename != NULL (default is \"imgui.ini\").", + "// - Set io.IniFilename to NULL to load/save manually. Read io.WantSaveIniSettings description about handling .ini saving manually.", + "// - Important: default value \"imgui.ini\" is relative to current working dir! Most apps will want to lock this to an absolute path (e.g. same path as executables)." + ], + "attached": "// call after CreateContext() and before the first call to NewFrame(). NewFrame() automatically calls LoadIniSettingsFromDisk(io.IniFilename)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1139 + } + }, + { + "name": "ImGui_LoadIniSettingsFromMemory", + "original_fully_qualified_name": "ImGui::LoadIniSettingsFromMemory", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ini_data", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "ini_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// call after CreateContext() and before the first call to NewFrame() to provide .ini data from your own data source." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1140 + } + }, + { + "name": "ImGui_SaveIniSettingsToDisk", + "original_fully_qualified_name": "ImGui::SaveIniSettingsToDisk", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ini_filename", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// this is automatically called (if io.IniFilename is not empty) a few seconds after any modification that should be reflected in the .ini file (and also by DestroyContext)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1141 + } + }, + { + "name": "ImGui_SaveIniSettingsToMemory", + "original_fully_qualified_name": "ImGui::SaveIniSettingsToMemory", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "out_ini_size", + "type": { + "declaration": "size_t*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "size_t" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// return a zero-terminated string with the .ini data which you can save by your own mean. call when io.WantSaveIniSettings is set, then save data by your own mean and clear io.WantSaveIniSettings." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1142 + } + }, + { + "name": "ImGui_DebugTextEncoding", + "original_fully_qualified_name": "ImGui::DebugTextEncoding", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Debug Utilities", + "// - Your main debugging friend is the ShowMetricsWindow() function, which is also accessible from Demo->Tools->Metrics Debugger" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1146 + } + }, + { + "name": "ImGui_DebugFlashStyleColor", + "original_fully_qualified_name": "ImGui::DebugFlashStyleColor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "idx", + "type": { + "declaration": "ImGuiCol", + "description": { + "kind": "User", + "name": "ImGuiCol" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1147 + } + }, + { + "name": "ImGui_DebugStartItemPicker", + "original_fully_qualified_name": "ImGui::DebugStartItemPicker", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1148 + } + }, + { + "name": "ImGui_DebugCheckVersionAndDataLayout", + "original_fully_qualified_name": "ImGui::DebugCheckVersionAndDataLayout", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "version_str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz_io", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz_style", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz_vec2", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz_vec4", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz_drawvert", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "sz_drawidx", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// This is called by IMGUI_CHECKVERSION() macro." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1149 + } + }, + { + "name": "ImGui_DebugLog", + "original_fully_qualified_name": "ImGui::DebugLog", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Call via IMGUI_DEBUG_LOG() for maximum stripping in caller code!" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEBUG_TOOLS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1151 + } + }, + { + "name": "ImGui_DebugLogV", + "original_fully_qualified_name": "ImGui::DebugLogV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_DEBUG_TOOLS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1152 + } + }, + { + "name": "ImGui_SetAllocatorFunctions", + "original_fully_qualified_name": "ImGui::SetAllocatorFunctions", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "alloc_func", + "type": { + "declaration": "ImGuiMemAllocFunc", + "description": { + "kind": "User", + "name": "ImGuiMemAllocFunc" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "free_func", + "type": { + "declaration": "ImGuiMemFreeFunc", + "description": { + "kind": "User", + "name": "ImGuiMemFreeFunc" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// Memory Allocators", + "// - Those functions are not reliant on the current context.", + "// - DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()", + "// for each static/DLL boundary you are calling from. Read \"Context and Memory Allocators\" section of imgui.cpp for more details." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1159 + } + }, + { + "name": "ImGui_GetAllocatorFunctions", + "original_fully_qualified_name": "ImGui::GetAllocatorFunctions", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_alloc_func", + "type": { + "declaration": "ImGuiMemAllocFunc*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMemAllocFunc" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_free_func", + "type": { + "declaration": "ImGuiMemFreeFunc*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMemFreeFunc" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_user_data", + "type": { + "declaration": "void**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1160 + } + }, + { + "name": "ImGui_MemAlloc", + "original_fully_qualified_name": "ImGui::MemAlloc", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1161 + } + }, + { + "name": "ImGui_MemFree", + "original_fully_qualified_name": "ImGui::MemFree", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "ptr", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1162 + } + }, + { + "name": "ImGui_UpdatePlatformWindows", + "original_fully_qualified_name": "ImGui::UpdatePlatformWindows", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// (Optional) Platform/OS interface for multi-viewport support", + "// Read comments around the ImGuiPlatformIO structure for more details.", + "// Note: You may use GetWindowViewport() to get the current viewport of the current window." + ], + "attached": "// call in main loop. will call CreateWindow/ResizeWindow/etc. platform functions for each secondary viewport, and DestroyWindow for each inactive viewport." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1167 + } + }, + { + "name": "ImGui_RenderPlatformWindowsDefault", + "original_fully_qualified_name": "ImGui::RenderPlatformWindowsDefault", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied platform_render_arg = NULL, renderer_render_arg = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1168 + } + }, + { + "name": "ImGui_RenderPlatformWindowsDefaultEx", + "original_fully_qualified_name": "ImGui::RenderPlatformWindowsDefault", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "platform_render_arg", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "renderer_render_arg", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// call in main loop. will call RenderWindow/SwapBuffers platform functions for each secondary viewport which doesn't have the ImGuiViewportFlags_Minimized flag set. May be reimplemented by user for custom rendering needs." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1168 + } + }, + { + "name": "ImGui_DestroyPlatformWindows", + "original_fully_qualified_name": "ImGui::DestroyPlatformWindows", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// call DestroyWindow platform functions for all viewports. call from backend Shutdown() if you need to close platform windows before imgui shutdown. otherwise will be called by DestroyContext()." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1169 + } + }, + { + "name": "ImGui_FindViewportByID", + "original_fully_qualified_name": "ImGui::FindViewportByID", + "return_type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// this is a helper for backends." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1170 + } + }, + { + "name": "ImGui_FindViewportByPlatformHandle", + "original_fully_qualified_name": "ImGui::FindViewportByPlatformHandle", + "return_type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "arguments": [ + { + "name": "platform_handle", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// this is a helper for backends. the type platform_handle is decided by the backend (e.g. HWND, MyWindow*, GLFWwindow* etc.)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1171 + } + }, + { + "name": "ImVector_Construct", + "original_fully_qualified_name": "ImVector_Construct", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vector", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": true, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Construct a zero-size ImVector<> (of any type). This is primarily useful when calling ImFontGlyphRangesBuilder_BuildRanges()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "ImVector_Destruct", + "original_fully_qualified_name": "ImVector_Destruct", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vector", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": true, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Destruct an ImVector<> (of any type). Important: Frees the vector memory but does not call destructors on contained objects (if they have them)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "ImGuiPlatformIO_SetPlatform_GetWindowWorkAreaInsets", + "original_fully_qualified_name": "ImGuiPlatformIO_SetPlatform_GetWindowWorkAreaInsets", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "getWindowWorkAreaInsetsFunc", + "type": { + "declaration": "void (*getWindowWorkAreaInsetsFunc)(ImGuiViewport* vp, ImVec4* result)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "result", + "type": { + "declaration": "ImVec4*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec4" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getWindowWorkAreaInsetsFunc", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "result", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec4" + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": true, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Set ImGuiPlatformIO::Platform_GetWindowWorkAreaInsets in a C-compatible mannner" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "ImGuiPlatformIO_SetPlatform_GetWindowFramebufferScale", + "original_fully_qualified_name": "ImGuiPlatformIO_SetPlatform_GetWindowFramebufferScale", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "getWindowFramebufferScaleFunc", + "type": { + "declaration": "void (*getWindowFramebufferScaleFunc)(ImGuiViewport* vp, ImVec2* result)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "result", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getWindowFramebufferScaleFunc", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "result", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": true, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Set ImGuiPlatformIO::Platform_GetWindowFramebufferScale in a C-compatible mannner" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "ImGuiPlatformIO_SetPlatform_GetWindowPos", + "original_fully_qualified_name": "ImGuiPlatformIO_SetPlatform_GetWindowPos", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "getWindowPosFunc", + "type": { + "declaration": "void (*getWindowPosFunc)(ImGuiViewport* vp, ImVec2* result)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "result", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getWindowPosFunc", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "result", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": true, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Set ImGuiPlatformIO::Platform_GetWindowPos in a C-compatible mannner" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "ImGuiPlatformIO_SetPlatform_GetWindowSize", + "original_fully_qualified_name": "ImGuiPlatformIO_SetPlatform_GetWindowSize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "getWindowSizeFunc", + "type": { + "declaration": "void (*getWindowSizeFunc)(ImGuiViewport* vp, ImVec2* result)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "vp", + "type": { + "declaration": "ImGuiViewport*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "result", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "getWindowSizeFunc", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "void" + }, + "parameters": [ + { + "kind": "Type", + "name": "vp", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiViewport" + } + } + }, + { + "kind": "Type", + "name": "result", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": true, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Set ImGuiPlatformIO::Platform_GetWindowSize in a C-compatible mannner" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "ImStr_FromCharStr", + "original_fully_qualified_name": "ImStr_FromCharStr", + "return_type": { + "declaration": "ImStr", + "description": { + "kind": "User", + "name": "ImStr" + } + }, + "arguments": [ + { + "name": "b", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": true, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Build an ImStr from a regular const char* (no data is copied, so you need to make sure the original char* isn't altered as long as you are using the ImStr)." + }, + "conditionals": [ + { + "condition": "if", + "expression": "defined(IMGUI_HAS_IMSTR)" + }, + { + "condition": "if", + "expression": "IMGUI_HAS_IMSTR" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 1 + } + }, + { + "name": "ImGuiStyle_ScaleAllSizes", + "original_fully_qualified_name": "ScaleAllSizes", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStyle*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStyle" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "scale_factor", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStyle", + "comments": { + "attached": "// Scale all spacing/padding/thickness values. Do not scale fonts." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2401 + } + }, + { + "name": "ImGuiIO_AddKeyEvent", + "original_fully_qualified_name": "AddKeyEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "down", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "preceding": [ + "// Input Functions" + ], + "attached": "// Queue a new key down/up event. Key should be \"translated\" (as in, generally ImGuiKey_A matches the key end-user would use to emit an 'A' character)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2570 + } + }, + { + "name": "ImGuiIO_AddKeyAnalogEvent", + "original_fully_qualified_name": "AddKeyAnalogEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "down", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a new key down/up event for analog values (e.g. ImGuiKey_Gamepad_ values). Dead-zones should be handled by the backend." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2571 + } + }, + { + "name": "ImGuiIO_AddMousePosEvent", + "original_fully_qualified_name": "AddMousePosEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a mouse position update. Use -FLT_MAX,-FLT_MAX to signify no mouse (e.g. app not focused and not hovered)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2572 + } + }, + { + "name": "ImGuiIO_AddMouseButtonEvent", + "original_fully_qualified_name": "AddMouseButtonEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "button", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "down", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a mouse button change" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2573 + } + }, + { + "name": "ImGuiIO_AddMouseWheelEvent", + "original_fully_qualified_name": "AddMouseWheelEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "wheel_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wheel_y", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a mouse wheel update. wheel_y<0: scroll down, wheel_y>0: scroll up, wheel_x<0: scroll right, wheel_x>0: scroll left." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2574 + } + }, + { + "name": "ImGuiIO_AddMouseSourceEvent", + "original_fully_qualified_name": "AddMouseSourceEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "source", + "type": { + "declaration": "ImGuiMouseSource", + "description": { + "kind": "User", + "name": "ImGuiMouseSource" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a mouse source change (Mouse/TouchScreen/Pen)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2575 + } + }, + { + "name": "ImGuiIO_AddMouseViewportEvent", + "original_fully_qualified_name": "AddMouseViewportEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a mouse hovered viewport. Requires backend to set ImGuiBackendFlags_HasMouseHoveredViewport to call this (for multi-viewport support)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2576 + } + }, + { + "name": "ImGuiIO_AddFocusEvent", + "original_fully_qualified_name": "AddFocusEvent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "focused", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a gain/loss of focus for the application (generally based on OS/platform focus of your window)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2577 + } + }, + { + "name": "ImGuiIO_AddInputCharacter", + "original_fully_qualified_name": "AddInputCharacter", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a new character input" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2578 + } + }, + { + "name": "ImGuiIO_AddInputCharacterUTF16", + "original_fully_qualified_name": "AddInputCharacterUTF16", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "ImWchar16", + "description": { + "kind": "User", + "name": "ImWchar16" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a new character input from a UTF-16 character, it can be a surrogate" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2579 + } + }, + { + "name": "ImGuiIO_AddInputCharactersUTF8", + "original_fully_qualified_name": "AddInputCharactersUTF8", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Queue a new characters input from a UTF-8 string" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2580 + } + }, + { + "name": "ImGuiIO_SetKeyEventNativeData", + "original_fully_qualified_name": "SetKeyEventNativeData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "native_keycode", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "native_scancode", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Implied native_legacy_index = -1" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2582 + } + }, + { + "name": "ImGuiIO_SetKeyEventNativeDataEx", + "original_fully_qualified_name": "SetKeyEventNativeData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiKey", + "description": { + "kind": "User", + "name": "ImGuiKey" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "native_keycode", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "native_scancode", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "native_legacy_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// [Optional] Specify index for legacy <1.87 IsKeyXXX() functions with native indices + specify native keycode, scancode." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2582 + } + }, + { + "name": "ImGuiIO_SetAppAcceptingEvents", + "original_fully_qualified_name": "SetAppAcceptingEvents", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "accepting_events", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Set master flag for accepting key/mouse/text events (default to true). Useful if you have native dialog boxes that are interrupting your application loop/refresh, and you want to disable events being queued while your app is frozen." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2583 + } + }, + { + "name": "ImGuiIO_ClearEventsQueue", + "original_fully_qualified_name": "ClearEventsQueue", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Clear all incoming events." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2584 + } + }, + { + "name": "ImGuiIO_ClearInputKeys", + "original_fully_qualified_name": "ClearInputKeys", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Clear current keyboard/gamepad state + current frame text input buffer. Equivalent to releasing all keys/buttons." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2585 + } + }, + { + "name": "ImGuiIO_ClearInputMouse", + "original_fully_qualified_name": "ClearInputMouse", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// Clear current mouse state." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2586 + } + }, + { + "name": "ImGuiIO_ClearInputCharacters", + "original_fully_qualified_name": "ClearInputCharacters", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiIO*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiIO", + "comments": { + "attached": "// [Obsoleted in 1.89.8] Clear the current frame text input buffer. Now included within ClearInputKeys()." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2588 + } + }, + { + "name": "ImGuiInputTextCallbackData_DeleteChars", + "original_fully_qualified_name": "DeleteChars", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextCallbackData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextCallbackData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "bytes_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextCallbackData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2719 + } + }, + { + "name": "ImGuiInputTextCallbackData_InsertChars", + "original_fully_qualified_name": "InsertChars", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextCallbackData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextCallbackData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextCallbackData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2720 + } + }, + { + "name": "ImGuiInputTextCallbackData_SelectAll", + "original_fully_qualified_name": "SelectAll", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextCallbackData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextCallbackData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextCallbackData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2721 + } + }, + { + "name": "ImGuiInputTextCallbackData_ClearSelection", + "original_fully_qualified_name": "ClearSelection", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiInputTextCallbackData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextCallbackData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextCallbackData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2722 + } + }, + { + "name": "ImGuiInputTextCallbackData_HasSelection", + "original_fully_qualified_name": "HasSelection", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiInputTextCallbackData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiInputTextCallbackData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiInputTextCallbackData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2723 + } + }, + { + "name": "ImGuiPayload_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiPayload*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiPayload" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiPayload", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2774 + } + }, + { + "name": "ImGuiPayload_IsDataType", + "original_fully_qualified_name": "IsDataType", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiPayload*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiPayload", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "type", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiPayload", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2775 + } + }, + { + "name": "ImGuiPayload_IsPreview", + "original_fully_qualified_name": "IsPreview", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiPayload*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiPayload", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiPayload", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2776 + } + }, + { + "name": "ImGuiPayload_IsDelivery", + "original_fully_qualified_name": "IsDelivery", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiPayload*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiPayload", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiPayload", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2777 + } + }, + { + "name": "ImGuiTextFilter_ImGuiTextRange_empty", + "original_fully_qualified_name": "empty", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextFilter_ImGuiTextRange*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter_ImGuiTextRange", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextFilter_ImGuiTextRange", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2819 + } + }, + { + "name": "ImGuiTextFilter_ImGuiTextRange_split", + "original_fully_qualified_name": "split", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextFilter_ImGuiTextRange*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter_ImGuiTextRange", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "separator", + "type": { + "declaration": "char", + "description": { + "kind": "Builtin", + "builtin_type": "char" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out", + "type": { + "declaration": "ImVector_ImGuiTextRange*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_ImGuiTextRange" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextFilter_ImGuiTextRange", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2820 + } + }, + { + "name": "ImGuiTextFilter_Draw", + "original_fully_qualified_name": "Draw", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextFilter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "\"Filter (inc,-exc)\"", + "is_instance_pointer": false + }, + { + "name": "width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextFilter", + "comments": { + "attached": "// Helper calling InputText+Build" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2805 + } + }, + { + "name": "ImGuiTextFilter_PassFilter", + "original_fully_qualified_name": "PassFilter", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextFilter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextFilter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2806 + } + }, + { + "name": "ImGuiTextFilter_Build", + "original_fully_qualified_name": "Build", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextFilter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextFilter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2807 + } + }, + { + "name": "ImGuiTextFilter_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextFilter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextFilter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2808 + } + }, + { + "name": "ImGuiTextFilter_IsActive", + "original_fully_qualified_name": "IsActive", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextFilter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextFilter", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextFilter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2809 + } + }, + { + "name": "ImGuiTextBuffer_begin", + "original_fully_qualified_name": "begin", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2836 + } + }, + { + "name": "ImGuiTextBuffer_end", + "original_fully_qualified_name": "end", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "comments": { + "attached": "// Buf is zero-terminated, so end() will point on the zero-terminator" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2837 + } + }, + { + "name": "ImGuiTextBuffer_size", + "original_fully_qualified_name": "size", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2838 + } + }, + { + "name": "ImGuiTextBuffer_empty", + "original_fully_qualified_name": "empty", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2839 + } + }, + { + "name": "ImGuiTextBuffer_clear", + "original_fully_qualified_name": "clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2840 + } + }, + { + "name": "ImGuiTextBuffer_resize", + "original_fully_qualified_name": "resize", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "comments": { + "attached": "// Similar to resize(0) on ImVector: empty string but don't free buffer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2841 + } + }, + { + "name": "ImGuiTextBuffer_reserve", + "original_fully_qualified_name": "reserve", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "capacity", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2842 + } + }, + { + "name": "ImGuiTextBuffer_c_str", + "original_fully_qualified_name": "c_str", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2843 + } + }, + { + "name": "ImGuiTextBuffer_append", + "original_fully_qualified_name": "append", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "str", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "str_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2844 + } + }, + { + "name": "ImGuiTextBuffer_appendf", + "original_fully_qualified_name": "appendf", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "is_array": false, + "is_varargs": true, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2845 + } + }, + { + "name": "ImGuiTextBuffer_appendfv", + "original_fully_qualified_name": "appendfv", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiTextBuffer*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiTextBuffer" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "fmt", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "args", + "type": { + "declaration": "va_list", + "description": { + "kind": "User", + "name": "va_list" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiTextBuffer", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2846 + } + }, + { + "name": "ImGuiStorage_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "comments": { + "preceding": [ + "// - Get***() functions find pair, never add/allocate. Pairs are sorted so a query is O(log N)", + "// - Set***() functions find pair, insertion on demand if missing.", + "// - Sorted insertion is costly, paid once. A typical frame shouldn't need to insert any new pair." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2875 + } + }, + { + "name": "ImGuiStorage_GetInt", + "original_fully_qualified_name": "GetInt", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_val", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2876 + } + }, + { + "name": "ImGuiStorage_SetInt", + "original_fully_qualified_name": "SetInt", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2877 + } + }, + { + "name": "ImGuiStorage_GetBool", + "original_fully_qualified_name": "GetBool", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_val", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2878 + } + }, + { + "name": "ImGuiStorage_SetBool", + "original_fully_qualified_name": "SetBool", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2879 + } + }, + { + "name": "ImGuiStorage_GetFloat", + "original_fully_qualified_name": "GetFloat", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_val", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2880 + } + }, + { + "name": "ImGuiStorage_SetFloat", + "original_fully_qualified_name": "SetFloat", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2881 + } + }, + { + "name": "ImGuiStorage_GetVoidPtr", + "original_fully_qualified_name": "GetVoidPtr", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "comments": { + "attached": "// default_val is NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2882 + } + }, + { + "name": "ImGuiStorage_SetVoidPtr", + "original_fully_qualified_name": "SetVoidPtr", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "val", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2883 + } + }, + { + "name": "ImGuiStorage_GetIntRef", + "original_fully_qualified_name": "GetIntRef", + "return_type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_val", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "comments": { + "preceding": [ + "// - Get***Ref() functions finds pair, insert on demand if missing, return pointer. Useful if you intend to do Get+Set.", + "// - References are only valid until a new value is added to the storage. Calling a Set***() function or a Get***Ref() function invalidates the pointer.", + "// - A typical use case where this is convenient for quick hacking (e.g. add storage during a live Edit&Continue session if you can't modify existing struct)", + "// float* pvar = ImGui::GetFloatRef(key); ImGui::SliderFloat(\"var\", pvar, 0, 100.0f); some_var += *pvar;" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2889 + } + }, + { + "name": "ImGuiStorage_GetBoolRef", + "original_fully_qualified_name": "GetBoolRef", + "return_type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_val", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2890 + } + }, + { + "name": "ImGuiStorage_GetFloatRef", + "original_fully_qualified_name": "GetFloatRef", + "return_type": { + "declaration": "float*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "float" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_val", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2891 + } + }, + { + "name": "ImGuiStorage_GetVoidPtrRef", + "original_fully_qualified_name": "GetVoidPtrRef", + "return_type": { + "declaration": "void**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "key", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "default_val", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2892 + } + }, + { + "name": "ImGuiStorage_BuildSortByKey", + "original_fully_qualified_name": "BuildSortByKey", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "comments": { + "preceding": [ + "// Advanced: for quicker full rebuild of a storage (instead of an incremental one), you may add all your contents and then sort once." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2895 + } + }, + { + "name": "ImGuiStorage_SetAllInt", + "original_fully_qualified_name": "SetAllInt", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "val", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiStorage", + "comments": { + "preceding": [ + "// Obsolete: use on your own storage if you know only integer are being stored (open/close all tree nodes)" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2897 + } + }, + { + "name": "ImGuiListClipper_Begin", + "original_fully_qualified_name": "Begin", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_height", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipper", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2939 + } + }, + { + "name": "ImGuiListClipper_End", + "original_fully_qualified_name": "End", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipper", + "comments": { + "attached": "// Automatically called on the last call of Step() that returns false." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2940 + } + }, + { + "name": "ImGuiListClipper_Step", + "original_fully_qualified_name": "Step", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipper", + "comments": { + "attached": "// Call until it returns false. The DisplayStart/DisplayEnd fields will be set and you can process/draw those items." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2941 + } + }, + { + "name": "ImGuiListClipper_IncludeItemByIndex", + "original_fully_qualified_name": "IncludeItemByIndex", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "item_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipper", + "comments": { + "preceding": [ + "// Call IncludeItemByIndex() or IncludeItemsByIndex() *BEFORE* first call to Step() if you need a range of items to not be clipped, regardless of their visibility.", + "// (Due to alignment / padding of certain items it is possible that an extra item may be included on either end of the display range)." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2945 + } + }, + { + "name": "ImGuiListClipper_IncludeItemsByIndex", + "original_fully_qualified_name": "IncludeItemsByIndex", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "item_begin", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "item_end", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipper", + "comments": { + "attached": "// item_end is exclusive e.g. use (42, 42+1) to make item 42 never clipped." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2946 + } + }, + { + "name": "ImGuiListClipper_SeekCursorForItem", + "original_fully_qualified_name": "SeekCursorForItem", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "item_index", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipper", + "comments": { + "preceding": [ + "// Seek cursor toward given item. This is automatically called while stepping.", + "// - The only reason to call this is: you can use ImGuiListClipper::Begin(INT_MAX) if you don't know item count ahead of time.", + "// - In this case, after all steps are done, you'll want to call SeekCursorForItem(item_count)." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2951 + } + }, + { + "name": "ImGuiListClipper_IncludeRangeByIndices", + "original_fully_qualified_name": "IncludeRangeByIndices", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiListClipper*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiListClipper" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "item_begin", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "item_end", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiListClipper", + "comments": { + "attached": "// [renamed in 1.89.9]" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 2954 + } + }, + { + "name": "ImColor_SetHSV", + "original_fully_qualified_name": "SetHSV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImColor*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImColor" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "h", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "s", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImColor", + "comments": { + "preceding": [ + "// FIXME-OBSOLETE: May need to obsolete/cleanup those helpers." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3037 + } + }, + { + "name": "ImColor_HSV", + "original_fully_qualified_name": "ImColor::HSV", + "return_type": { + "declaration": "ImColor", + "description": { + "kind": "User", + "name": "ImColor" + } + }, + "arguments": [ + { + "name": "h", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "s", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "v", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": true, + "original_class": "ImColor", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3038 + } + }, + { + "name": "ImGuiSelectionBasicStorage_ApplyRequests", + "original_fully_qualified_name": "ApplyRequests", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "ms_io", + "type": { + "declaration": "ImGuiMultiSelectIO*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionBasicStorage", + "comments": { + "attached": "// Apply selection requests coming from BeginMultiSelect() and EndMultiSelect() functions. It uses 'items_count' passed to BeginMultiSelect()" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3167 + } + }, + { + "name": "ImGuiSelectionBasicStorage_Contains", + "original_fully_qualified_name": "Contains", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionBasicStorage", + "comments": { + "attached": "// Query if an item id is in selection." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3168 + } + }, + { + "name": "ImGuiSelectionBasicStorage_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionBasicStorage", + "comments": { + "attached": "// Clear selection" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3169 + } + }, + { + "name": "ImGuiSelectionBasicStorage_Swap", + "original_fully_qualified_name": "Swap", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "is_reference": true, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionBasicStorage", + "comments": { + "attached": "// Swap two selections" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3170 + } + }, + { + "name": "ImGuiSelectionBasicStorage_SetItemSelected", + "original_fully_qualified_name": "SetItemSelected", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "selected", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionBasicStorage", + "comments": { + "attached": "// Add/remove an item from selection (generally done by ApplyRequests() function)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3171 + } + }, + { + "name": "ImGuiSelectionBasicStorage_GetNextSelectedItem", + "original_fully_qualified_name": "GetNextSelectedItem", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "opaque_it", + "type": { + "declaration": "void**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_id", + "type": { + "declaration": "ImGuiID*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiID" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionBasicStorage", + "comments": { + "attached": "// Iterate selection with 'void* it = NULL; ImGuiID id; while (selection.GetNextSelectedItem(&it, &id)) { ... }'" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3172 + } + }, + { + "name": "ImGuiSelectionBasicStorage_GetStorageIdFromIndex", + "original_fully_qualified_name": "GetStorageIdFromIndex", + "return_type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionBasicStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionBasicStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionBasicStorage", + "comments": { + "attached": "// Convert index to item id based on provided adapter." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3173 + } + }, + { + "name": "ImGuiSelectionExternalStorage_ApplyRequests", + "original_fully_qualified_name": "ApplyRequests", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImGuiSelectionExternalStorage*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiSelectionExternalStorage" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "ms_io", + "type": { + "declaration": "ImGuiMultiSelectIO*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImGuiMultiSelectIO" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiSelectionExternalStorage", + "comments": { + "attached": "// Apply selection requests by using AdapterSetItemSelected() calls" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3186 + } + }, + { + "name": "ImDrawCmd_GetTexID", + "original_fully_qualified_name": "GetTexID", + "return_type": { + "declaration": "ImTextureID", + "description": { + "kind": "User", + "name": "ImTextureID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImDrawCmd*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawCmd", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawCmd", + "comments": { + "preceding": [ + "// Since 1.83: returns ImTextureID associated with this draw call. Warning: DO NOT assume this is always same as 'TextureId' (we will change this function for an upcoming feature)", + "// Since 1.92: removed ImDrawCmd::TextureId field, the getter function must be used!" + ], + "attached": "// == (TexRef._TexData ? TexRef._TexData->TexID : TexRef._TexID" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3244 + } + }, + { + "name": "ImDrawListSplitter_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawListSplitter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawListSplitter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawListSplitter", + "comments": { + "attached": "// Do not clear Channels[] so our allocations are reused next frame" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3288 + } + }, + { + "name": "ImDrawListSplitter_ClearFreeMemory", + "original_fully_qualified_name": "ClearFreeMemory", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawListSplitter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawListSplitter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawListSplitter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3289 + } + }, + { + "name": "ImDrawListSplitter_Split", + "original_fully_qualified_name": "Split", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawListSplitter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawListSplitter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawListSplitter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3290 + } + }, + { + "name": "ImDrawListSplitter_Merge", + "original_fully_qualified_name": "Merge", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawListSplitter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawListSplitter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawListSplitter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3291 + } + }, + { + "name": "ImDrawListSplitter_SetCurrentChannel", + "original_fully_qualified_name": "SetCurrentChannel", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawListSplitter*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawListSplitter" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "channel_idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawListSplitter", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3292 + } + }, + { + "name": "ImDrawList_PushClipRect", + "original_fully_qualified_name": "PushClipRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "clip_rect_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clip_rect_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "intersect_with_current_clip_rect", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Render-level scissoring. This is passed down to your render function but not used for CPU-side coarse clipping. Prefer using higher-level ImGui::PushClipRect() to affect logic (hit-testing and widget culling)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3362 + } + }, + { + "name": "ImDrawList_PushClipRectFullScreen", + "original_fully_qualified_name": "PushClipRectFullScreen", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3363 + } + }, + { + "name": "ImDrawList_PopClipRect", + "original_fully_qualified_name": "PopClipRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3364 + } + }, + { + "name": "ImDrawList_PushTexture", + "original_fully_qualified_name": "PushTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3365 + } + }, + { + "name": "ImDrawList_PopTexture", + "original_fully_qualified_name": "PopTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3366 + } + }, + { + "name": "ImDrawList_GetClipRectMin", + "original_fully_qualified_name": "GetClipRectMin", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3367 + } + }, + { + "name": "ImDrawList_GetClipRectMax", + "original_fully_qualified_name": "GetClipRectMax", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3368 + } + }, + { + "name": "ImDrawList_AddLine", + "original_fully_qualified_name": "AddLine", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// Primitives", + "// - Filled shapes must always use clockwise winding order. The anti-aliasing fringe depends on it. Counter-clockwise shapes will have \"inward\" anti-aliasing.", + "// - For rectangular primitives, \"p_min\" and \"p_max\" represent the upper-left and lower-right corners.", + "// - For circle primitives, use \"num_segments == 0\" to automatically calculate tessellation (preferred).", + "// In older versions (until Dear ImGui 1.77) the AddCircle functions defaulted to num_segments == 12.", + "// In future versions we will use textures to provide cheaper and higher-quality circles.", + "// Use AddNgon() and AddNgonFilled() functions if you need to guarantee a specific number of sides." + ], + "attached": "// Implied thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3377 + } + }, + { + "name": "ImDrawList_AddLineEx", + "original_fully_qualified_name": "AddLine", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3377 + } + }, + { + "name": "ImDrawList_AddRect", + "original_fully_qualified_name": "AddRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied rounding = 0.0f, flags = 0, thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3378 + } + }, + { + "name": "ImDrawList_AddRectEx", + "original_fully_qualified_name": "AddRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// a: upper-left, b: lower-right (== upper-left + size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3378 + } + }, + { + "name": "ImDrawList_AddRectFilled", + "original_fully_qualified_name": "AddRectFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied rounding = 0.0f, flags = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3379 + } + }, + { + "name": "ImDrawList_AddRectFilledEx", + "original_fully_qualified_name": "AddRectFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// a: upper-left, b: lower-right (== upper-left + size)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3379 + } + }, + { + "name": "ImDrawList_AddRectFilledMultiColor", + "original_fully_qualified_name": "AddRectFilledMultiColor", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_upr_left", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_upr_right", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_bot_right", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col_bot_left", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3380 + } + }, + { + "name": "ImDrawList_AddQuad", + "original_fully_qualified_name": "AddQuad", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3381 + } + }, + { + "name": "ImDrawList_AddQuadEx", + "original_fully_qualified_name": "AddQuad", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3381 + } + }, + { + "name": "ImDrawList_AddQuadFilled", + "original_fully_qualified_name": "AddQuadFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3382 + } + }, + { + "name": "ImDrawList_AddTriangle", + "original_fully_qualified_name": "AddTriangle", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3383 + } + }, + { + "name": "ImDrawList_AddTriangleEx", + "original_fully_qualified_name": "AddTriangle", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3383 + } + }, + { + "name": "ImDrawList_AddTriangleFilled", + "original_fully_qualified_name": "AddTriangleFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3384 + } + }, + { + "name": "ImDrawList_AddCircle", + "original_fully_qualified_name": "AddCircle", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied num_segments = 0, thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3385 + } + }, + { + "name": "ImDrawList_AddCircleEx", + "original_fully_qualified_name": "AddCircle", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3385 + } + }, + { + "name": "ImDrawList_AddCircleFilled", + "original_fully_qualified_name": "AddCircleFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3386 + } + }, + { + "name": "ImDrawList_AddNgon", + "original_fully_qualified_name": "AddNgon", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3387 + } + }, + { + "name": "ImDrawList_AddNgonEx", + "original_fully_qualified_name": "AddNgon", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3387 + } + }, + { + "name": "ImDrawList_AddNgonFilled", + "original_fully_qualified_name": "AddNgonFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3388 + } + }, + { + "name": "ImDrawList_AddEllipse", + "original_fully_qualified_name": "AddEllipse", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied rot = 0.0f, num_segments = 0, thickness = 1.0f" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3389 + } + }, + { + "name": "ImDrawList_AddEllipseEx", + "original_fully_qualified_name": "AddEllipse", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rot", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3389 + } + }, + { + "name": "ImDrawList_AddEllipseFilled", + "original_fully_qualified_name": "AddEllipseFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied rot = 0.0f, num_segments = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3390 + } + }, + { + "name": "ImDrawList_AddEllipseFilledEx", + "original_fully_qualified_name": "AddEllipseFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rot", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3390 + } + }, + { + "name": "ImDrawList_AddText", + "original_fully_qualified_name": "AddText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied text_end = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3391 + } + }, + { + "name": "ImDrawList_AddTextEx", + "original_fully_qualified_name": "AddText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3391 + } + }, + { + "name": "ImDrawList_AddTextImFontPtr", + "original_fully_qualified_name": "AddText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied text_end = NULL, wrap_width = 0.0f, cpu_fine_clip_rect = NULL" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3392 + } + }, + { + "name": "ImDrawList_AddTextImFontPtrEx", + "original_fully_qualified_name": "AddText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "cpu_fine_clip_rect", + "type": { + "declaration": "const ImVec4*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec4", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3392 + } + }, + { + "name": "ImDrawList_AddBezierCubic", + "original_fully_qualified_name": "AddBezierCubic", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Cubic Bezier (4 control points)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3393 + } + }, + { + "name": "ImDrawList_AddBezierQuadratic", + "original_fully_qualified_name": "AddBezierQuadratic", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Quadratic Bezier (3 control points)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3394 + } + }, + { + "name": "ImDrawList_AddPolyline", + "original_fully_qualified_name": "AddPolyline", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "points", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_points", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// General polygon", + "// - Only simple polygons are supported by filling functions (no self-intersections, no holes).", + "// - Concave polygon fill is more expensive than convex one: it has O(N^2) complexity. Provided as a convenience for the user but not used by the main library." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3399 + } + }, + { + "name": "ImDrawList_AddConvexPolyFilled", + "original_fully_qualified_name": "AddConvexPolyFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "points", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_points", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3400 + } + }, + { + "name": "ImDrawList_AddConcavePolyFilled", + "original_fully_qualified_name": "AddConcavePolyFilled", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "points", + "type": { + "declaration": "const ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_points", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3401 + } + }, + { + "name": "ImDrawList_AddImage", + "original_fully_qualified_name": "AddImage", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// Image primitives", + "// - Read FAQ to understand what ImTextureID/ImTextureRef are.", + "// - \"p_min\" and \"p_max\" represent the upper-left and lower-right corners of the rectangle.", + "// - \"uv_min\" and \"uv_max\" represent the normalized texture coordinates to use for those corners. Using (0,0)->(1,1) texture coordinates will generally display the entire texture." + ], + "attached": "// Implied uv_min = ImVec2(0, 0), uv_max = ImVec2(1, 1), col = IM_COL32_WHITE" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3407 + } + }, + { + "name": "ImDrawList_AddImageEx", + "original_fully_qualified_name": "AddImage", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "uv_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(1, 1)", + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "IM_COL32_WHITE", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3407 + } + }, + { + "name": "ImDrawList_AddImageQuad", + "original_fully_qualified_name": "AddImageQuad", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied uv1 = ImVec2(0, 0), uv2 = ImVec2(1, 0), uv3 = ImVec2(1, 1), uv4 = ImVec2(0, 1), col = IM_COL32_WHITE" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3408 + } + }, + { + "name": "ImDrawList_AddImageQuadEx", + "original_fully_qualified_name": "AddImageQuad", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + }, + { + "name": "uv2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(1, 0)", + "is_instance_pointer": false + }, + { + "name": "uv3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(1, 1)", + "is_instance_pointer": false + }, + { + "name": "uv4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 1)", + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "IM_COL32_WHITE", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3408 + } + }, + { + "name": "ImDrawList_AddImageRounded", + "original_fully_qualified_name": "AddImageRounded", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3409 + } + }, + { + "name": "ImDrawList_PathClear", + "original_fully_qualified_name": "PathClear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// Stateful path API, add points then finish with PathFillConvex() or PathStroke()", + "// - Important: filled shapes must always use clockwise winding order! The anti-aliasing fringe depends on it. Counter-clockwise shapes will have \"inward\" anti-aliasing.", + "// so e.g. 'PathArcTo(center, radius, PI * -0.5f, PI)' is ok, whereas 'PathArcTo(center, radius, PI, PI * -0.5f)' won't have correct anti-aliasing when followed by PathFillConvex()." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3414 + } + }, + { + "name": "ImDrawList_PathLineTo", + "original_fully_qualified_name": "PathLineTo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3415 + } + }, + { + "name": "ImDrawList_PathLineToMergeDuplicate", + "original_fully_qualified_name": "PathLineToMergeDuplicate", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3416 + } + }, + { + "name": "ImDrawList_PathFillConvex", + "original_fully_qualified_name": "PathFillConvex", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3417 + } + }, + { + "name": "ImDrawList_PathFillConcave", + "original_fully_qualified_name": "PathFillConcave", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3418 + } + }, + { + "name": "ImDrawList_PathStroke", + "original_fully_qualified_name": "PathStroke", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + }, + { + "name": "thickness", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3419 + } + }, + { + "name": "ImDrawList_PathArcTo", + "original_fully_qualified_name": "PathArcTo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3420 + } + }, + { + "name": "ImDrawList_PathArcToFast", + "original_fully_qualified_name": "PathArcToFast", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_min_of_12", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_max_of_12", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Use precomputed angles for a 12 steps circle" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3421 + } + }, + { + "name": "ImDrawList_PathEllipticalArcTo", + "original_fully_qualified_name": "PathEllipticalArcTo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rot", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Implied num_segments = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3422 + } + }, + { + "name": "ImDrawList_PathEllipticalArcToEx", + "original_fully_qualified_name": "PathEllipticalArcTo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rot", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Ellipse" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3422 + } + }, + { + "name": "ImDrawList_PathBezierCubicCurveTo", + "original_fully_qualified_name": "PathBezierCubicCurveTo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p4", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Cubic Bezier (4 control points)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3423 + } + }, + { + "name": "ImDrawList_PathBezierQuadraticCurveTo", + "original_fully_qualified_name": "PathBezierQuadraticCurveTo", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "p2", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "p3", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Quadratic Bezier (3 control points)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3424 + } + }, + { + "name": "ImDrawList_PathRect", + "original_fully_qualified_name": "PathRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "rect_min", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rect_max", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "rounding", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "flags", + "type": { + "declaration": "ImDrawFlags", + "description": { + "kind": "User", + "name": "ImDrawFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3425 + } + }, + { + "name": "ImDrawList_AddCallback", + "original_fully_qualified_name": "AddCallback", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "callback", + "type": { + "declaration": "ImDrawCallback", + "description": { + "kind": "User", + "name": "ImDrawCallback" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "userdata", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// Advanced: Draw Callbacks", + "// - May be used to alter render state (change sampler, blending, current shader). May be used to emit custom rendering commands (difficult to do correctly, but possible).", + "// - Use special ImDrawCallback_ResetRenderState callback to instruct backend to reset its render state to the default.", + "// - Your rendering loop must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles. All standard backends are honoring this.", + "// - For some backends, the callback may access selected render-states exposed by the backend in a ImGui_ImplXXXX_RenderState structure pointed to by platform_io.Renderer_RenderState.", + "// - IMPORTANT: please be mindful of the different level of indirection between using size==0 (copying argument) and using size>0 (copying pointed data into a buffer).", + "// - If userdata_size == 0: we copy/store the 'userdata' argument as-is. It will be available unmodified in ImDrawCmd::UserCallbackData during render.", + "// - If userdata_size > 0, we copy/store 'userdata_size' bytes pointed to by 'userdata'. We store them in a buffer stored inside the drawlist. ImDrawCmd::UserCallbackData will point inside that buffer so you have to retrieve data from there. Your callback may need to use ImDrawCmd::UserCallbackDataSize if you expect dynamically-sized data.", + "// - Support for userdata_size > 0 was added in v1.91.4, October 2024. So earlier code always only allowed to copy/store a simple void*." + ], + "attached": "// Implied userdata_size = 0" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3436 + } + }, + { + "name": "ImDrawList_AddCallbackEx", + "original_fully_qualified_name": "AddCallback", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "callback", + "type": { + "declaration": "ImDrawCallback", + "description": { + "kind": "User", + "name": "ImDrawCallback" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "userdata", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "userdata_size", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3436 + } + }, + { + "name": "ImDrawList_AddDrawCmd", + "original_fully_qualified_name": "AddDrawCmd", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// Advanced: Miscellaneous" + ], + "attached": "// This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3439 + } + }, + { + "name": "ImDrawList_CloneOutput", + "original_fully_qualified_name": "CloneOutput", + "return_type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Create a clone of the CmdBuffer/IdxBuffer/VtxBuffer." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3440 + } + }, + { + "name": "ImDrawList_ChannelsSplit", + "original_fully_qualified_name": "ChannelsSplit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// Advanced: Channels", + "// - Use to split render into layers. By switching channels to can render out-of-order (e.g. submit FG primitives before BG primitives)", + "// - Use to minimize draw calls (e.g. if going back-and-forth between multiple clipping rectangles, prefer to append into separate channels then merge at the end)", + "// - This API shouldn't have been in ImDrawList in the first place!", + "// Prefer using your own persistent instance of ImDrawListSplitter as you can stack them.", + "// Using the ImDrawList::ChannelsXXXX you cannot stack a split over another." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3448 + } + }, + { + "name": "ImDrawList_ChannelsMerge", + "original_fully_qualified_name": "ChannelsMerge", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3449 + } + }, + { + "name": "ImDrawList_ChannelsSetCurrent", + "original_fully_qualified_name": "ChannelsSetCurrent", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "n", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3450 + } + }, + { + "name": "ImDrawList_PrimReserve", + "original_fully_qualified_name": "PrimReserve", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "idx_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vtx_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// Advanced: Primitives allocations", + "// - We render triangles (three vertices)", + "// - All primitives needs to be reserved via PrimReserve() beforehand." + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3455 + } + }, + { + "name": "ImDrawList_PrimUnreserve", + "original_fully_qualified_name": "PrimUnreserve", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "idx_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "vtx_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3456 + } + }, + { + "name": "ImDrawList_PrimRect", + "original_fully_qualified_name": "PrimRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Axis aligned rectangle (composed of two triangles)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3457 + } + }, + { + "name": "ImDrawList_PrimRectUV", + "original_fully_qualified_name": "PrimRectUV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3458 + } + }, + { + "name": "ImDrawList_PrimQuadUV", + "original_fully_qualified_name": "PrimQuadUV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "d", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_a", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_b", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_c", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv_d", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3459 + } + }, + { + "name": "ImDrawList_PrimWriteVtx", + "original_fully_qualified_name": "PrimWriteVtx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3460 + } + }, + { + "name": "ImDrawList_PrimWriteIdx", + "original_fully_qualified_name": "PrimWriteIdx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "idx", + "type": { + "declaration": "ImDrawIdx", + "description": { + "kind": "User", + "name": "ImDrawIdx" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3461 + } + }, + { + "name": "ImDrawList_PrimVtx", + "original_fully_qualified_name": "PrimVtx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// Write vertex with unique index" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3462 + } + }, + { + "name": "ImDrawList_PushTextureID", + "original_fully_qualified_name": "PushTextureID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// RENAMED in 1.92.x" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3466 + } + }, + { + "name": "ImDrawList_PopTextureID", + "original_fully_qualified_name": "PopTextureID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "attached": "// RENAMED in 1.92.x" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3467 + } + }, + { + "name": "ImDrawList__SetDrawListSharedData", + "original_fully_qualified_name": "_SetDrawListSharedData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "data", + "type": { + "declaration": "ImDrawListSharedData*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawListSharedData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "comments": { + "preceding": [ + "// [Internal helpers]" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3476 + } + }, + { + "name": "ImDrawList__ResetForNewFrame", + "original_fully_qualified_name": "_ResetForNewFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3477 + } + }, + { + "name": "ImDrawList__ClearFreeMemory", + "original_fully_qualified_name": "_ClearFreeMemory", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3478 + } + }, + { + "name": "ImDrawList__PopUnusedDrawCmd", + "original_fully_qualified_name": "_PopUnusedDrawCmd", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3479 + } + }, + { + "name": "ImDrawList__TryMergeDrawCmds", + "original_fully_qualified_name": "_TryMergeDrawCmds", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3480 + } + }, + { + "name": "ImDrawList__OnChangedClipRect", + "original_fully_qualified_name": "_OnChangedClipRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3481 + } + }, + { + "name": "ImDrawList__OnChangedTexture", + "original_fully_qualified_name": "_OnChangedTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3482 + } + }, + { + "name": "ImDrawList__OnChangedVtxOffset", + "original_fully_qualified_name": "_OnChangedVtxOffset", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3483 + } + }, + { + "name": "ImDrawList__SetTexture", + "original_fully_qualified_name": "_SetTexture", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3484 + } + }, + { + "name": "ImDrawList__CalcCircleAutoSegmentCount", + "original_fully_qualified_name": "_CalcCircleAutoSegmentCount", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3485 + } + }, + { + "name": "ImDrawList__PathArcToFastEx", + "original_fully_qualified_name": "_PathArcToFastEx", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_min_sample", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_max_sample", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_step", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3486 + } + }, + { + "name": "ImDrawList__PathArcToN", + "original_fully_qualified_name": "_PathArcToN", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "center", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "radius", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_min", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "a_max", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "num_segments", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawList", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3487 + } + }, + { + "name": "ImDrawData_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3508 + } + }, + { + "name": "ImDrawData_AddDrawList", + "original_fully_qualified_name": "AddDrawList", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawData", + "comments": { + "attached": "// Helper to add an external draw list into an existing ImDrawData." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3509 + } + }, + { + "name": "ImDrawData_DeIndexAllBuffers", + "original_fully_qualified_name": "DeIndexAllBuffers", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawData", + "comments": { + "attached": "// Helper to convert all buffers from indexed to non-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3510 + } + }, + { + "name": "ImDrawData_ScaleClipRects", + "original_fully_qualified_name": "ScaleClipRects", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImDrawData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImDrawData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "fb_scale", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImDrawData", + "comments": { + "attached": "// Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than Dear ImGui expects, or if there is a difference between your window resolution and framebuffer resolution." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3511 + } + }, + { + "name": "ImTextureData_Create", + "original_fully_qualified_name": "Create", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "format", + "type": { + "declaration": "ImTextureFormat", + "description": { + "kind": "User", + "name": "ImTextureFormat" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3581 + } + }, + { + "name": "ImTextureData_DestroyPixels", + "original_fully_qualified_name": "DestroyPixels", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3582 + } + }, + { + "name": "ImTextureData_GetPixels", + "original_fully_qualified_name": "GetPixels", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3583 + } + }, + { + "name": "ImTextureData_GetPixelsAt", + "original_fully_qualified_name": "GetPixelsAt", + "return_type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "x", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "y", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3584 + } + }, + { + "name": "ImTextureData_GetSizeInBytes", + "original_fully_qualified_name": "GetSizeInBytes", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3585 + } + }, + { + "name": "ImTextureData_GetPitch", + "original_fully_qualified_name": "GetPitch", + "return_type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3586 + } + }, + { + "name": "ImTextureData_GetTexRef", + "original_fully_qualified_name": "GetTexRef", + "return_type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3587 + } + }, + { + "name": "ImTextureData_GetTexID", + "original_fully_qualified_name": "GetTexID", + "return_type": { + "declaration": "ImTextureID", + "description": { + "kind": "User", + "name": "ImTextureID" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3588 + } + }, + { + "name": "ImTextureData_SetTexID", + "original_fully_qualified_name": "SetTexID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "tex_id", + "type": { + "declaration": "ImTextureID", + "description": { + "kind": "User", + "name": "ImTextureID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "comments": { + "preceding": [ + "// Called by Renderer backend" + ], + "attached": "// Call after creating or destroying the texture. Never modify TexID directly!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3591 + } + }, + { + "name": "ImTextureData_SetStatus", + "original_fully_qualified_name": "SetStatus", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImTextureData*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImTextureData" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "status", + "type": { + "declaration": "ImTextureStatus", + "description": { + "kind": "User", + "name": "ImTextureStatus" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImTextureData", + "comments": { + "attached": "// Call after honoring a request. Never modify Status directly!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3592 + } + }, + { + "name": "ImFontGlyphRangesBuilder_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontGlyphRangesBuilder*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontGlyphRangesBuilder" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontGlyphRangesBuilder", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3661 + } + }, + { + "name": "ImFontGlyphRangesBuilder_GetBit", + "original_fully_qualified_name": "GetBit", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImFontGlyphRangesBuilder*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontGlyphRangesBuilder", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "n", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontGlyphRangesBuilder", + "comments": { + "attached": "// Get bit n in the array" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3662 + } + }, + { + "name": "ImFontGlyphRangesBuilder_SetBit", + "original_fully_qualified_name": "SetBit", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontGlyphRangesBuilder*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontGlyphRangesBuilder" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "n", + "type": { + "declaration": "size_t", + "description": { + "kind": "User", + "name": "size_t" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontGlyphRangesBuilder", + "comments": { + "attached": "// Set bit n in the array" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3663 + } + }, + { + "name": "ImFontGlyphRangesBuilder_AddChar", + "original_fully_qualified_name": "AddChar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontGlyphRangesBuilder*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontGlyphRangesBuilder" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontGlyphRangesBuilder", + "comments": { + "attached": "// Add character" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3664 + } + }, + { + "name": "ImFontGlyphRangesBuilder_AddText", + "original_fully_qualified_name": "AddText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontGlyphRangesBuilder*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontGlyphRangesBuilder" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontGlyphRangesBuilder", + "comments": { + "attached": "// Add string (each character of the UTF-8 string are added)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3665 + } + }, + { + "name": "ImFontGlyphRangesBuilder_AddRanges", + "original_fully_qualified_name": "AddRanges", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontGlyphRangesBuilder*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontGlyphRangesBuilder" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "ranges", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontGlyphRangesBuilder", + "comments": { + "attached": "// Add ranges, e.g. builder.AddRanges(ImFontAtlas::GetGlyphRangesDefault()) to force add all of ASCII/Latin+Ext" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3666 + } + }, + { + "name": "ImFontGlyphRangesBuilder_BuildRanges", + "original_fully_qualified_name": "BuildRanges", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontGlyphRangesBuilder*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontGlyphRangesBuilder" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "out_ranges", + "type": { + "declaration": "ImVector_ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVector_ImWchar" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontGlyphRangesBuilder", + "comments": { + "attached": "// Output new ranges (ImVector_Construct()/ImVector_Destruct() can be used to safely construct out_ranges)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3667 + } + }, + { + "name": "ImFontAtlas_AddFont", + "original_fully_qualified_name": "AddFont", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font_cfg", + "type": { + "declaration": "const ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3719 + } + }, + { + "name": "ImFontAtlas_AddFontDefault", + "original_fully_qualified_name": "AddFontDefault", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font_cfg", + "type": { + "declaration": "const ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3720 + } + }, + { + "name": "ImFontAtlas_AddFontFromFileTTF", + "original_fully_qualified_name": "AddFontFromFileTTF", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "filename", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_pixels", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "font_cfg", + "type": { + "declaration": "const ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "glyph_ranges", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3721 + } + }, + { + "name": "ImFontAtlas_AddFontFromMemoryTTF", + "original_fully_qualified_name": "AddFontFromMemoryTTF", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_data_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_pixels", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "font_cfg", + "type": { + "declaration": "const ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "glyph_ranges", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Note: Transfer ownership of 'ttf_data' to ImFontAtlas! Will be deleted after destruction of the atlas. Set font_cfg->FontDataOwnedByAtlas=false to keep ownership of your data and it won't be freed." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3722 + } + }, + { + "name": "ImFontAtlas_AddFontFromMemoryCompressedTTF", + "original_fully_qualified_name": "AddFontFromMemoryCompressedTTF", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "compressed_font_data", + "type": { + "declaration": "const void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "compressed_font_data_size", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_pixels", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "font_cfg", + "type": { + "declaration": "const ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "glyph_ranges", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// 'compressed_font_data' still owned by caller. Compress with binary_to_compressed_c.cpp." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3723 + } + }, + { + "name": "ImFontAtlas_AddFontFromMemoryCompressedBase85TTF", + "original_fully_qualified_name": "AddFontFromMemoryCompressedBase85TTF", + "return_type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "compressed_font_data_base85", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size_pixels", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "font_cfg", + "type": { + "declaration": "const ImFontConfig*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontConfig", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "glyph_ranges", + "type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// 'compressed_font_data_base85' still owned by caller. Compress with binary_to_compressed_c.cpp with -base85 parameter." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3724 + } + }, + { + "name": "ImFontAtlas_RemoveFont", + "original_fully_qualified_name": "RemoveFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3725 + } + }, + { + "name": "ImFontAtlas_Clear", + "original_fully_qualified_name": "Clear", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Clear everything (input fonts, output glyphs/textures)" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3727 + } + }, + { + "name": "ImFontAtlas_CompactCache", + "original_fully_qualified_name": "CompactCache", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Compact cached glyphs and texture." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3728 + } + }, + { + "name": "ImFontAtlas_SetFontLoader", + "original_fully_qualified_name": "SetFontLoader", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font_loader", + "type": { + "declaration": "const ImFontLoader*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontLoader", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Change font loader at runtime." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3729 + } + }, + { + "name": "ImFontAtlas_ClearInputData", + "original_fully_qualified_name": "ClearInputData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "preceding": [ + "// As we are transitioning toward a new font system, we expect to obsolete those soon:" + ], + "attached": "// [OBSOLETE] Clear input data (all ImFontConfig structures including sizes, TTF data, glyph ranges, etc.) = all the data used to build the texture and fonts." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3732 + } + }, + { + "name": "ImFontAtlas_ClearFonts", + "original_fully_qualified_name": "ClearFonts", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// [OBSOLETE] Clear input+output font data (same as ClearInputData() + glyphs storage, UV coordinates)." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3733 + } + }, + { + "name": "ImFontAtlas_ClearTexData", + "original_fully_qualified_name": "ClearTexData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// [OBSOLETE] Clear CPU-side copy of the texture data. Saves RAM once the texture has been copied to graphics memory." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3734 + } + }, + { + "name": "ImFontAtlas_Build", + "original_fully_qualified_name": "Build", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "preceding": [ + "// Legacy path for build atlas + retrieving pixel data.", + "// - User is in charge of copying the pixels into graphics memory (e.g. create a texture with your engine). Then store your texture handle with SetTexID().", + "// - The pitch is always = Width * BytesPerPixels (1 or 4)", + "// - Building in RGBA32 format is provided for convenience and compatibility, but note that unless you manually manipulate or copy color data into", + "// the texture (e.g. when using the AddCustomRect*** api), then the RGB pixels emitted will always be white (~75% of memory/bandwidth waste.", + "// - From 1.92 with backends supporting ImGuiBackendFlags_RendererHasTextures:", + "// - Calling Build(), GetTexDataAsAlpha8(), GetTexDataAsRGBA32() is not needed.", + "// - In backend: replace calls to ImFontAtlas::SetTexID() with calls to ImTextureData::SetTexID() after honoring texture creation." + ], + "attached": "// Build pixels data. This is called automatically for you by the GetTexData*** functions." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3745 + } + }, + { + "name": "ImFontAtlas_GetTexDataAsAlpha8", + "original_fully_qualified_name": "GetTexDataAsAlpha8", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "out_pixels", + "type": { + "declaration": "unsigned char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char" + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_width", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_height", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_bytes_per_pixel", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// 1 byte per-pixel" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3746 + } + }, + { + "name": "ImFontAtlas_GetTexDataAsRGBA32", + "original_fully_qualified_name": "GetTexDataAsRGBA32", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "out_pixels", + "type": { + "declaration": "unsigned char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "unsigned_char" + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_width", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_height", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_bytes_per_pixel", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// 4 bytes-per-pixel" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3747 + } + }, + { + "name": "ImFontAtlas_SetTexID", + "original_fully_qualified_name": "SetTexID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImTextureID", + "description": { + "kind": "User", + "name": "ImTextureID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Called by legacy backends. May be called before texture creation." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3748 + } + }, + { + "name": "ImFontAtlas_SetTexIDImTextureRef", + "original_fully_qualified_name": "SetTexID", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Called by legacy backends." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3749 + } + }, + { + "name": "ImFontAtlas_IsBuilt", + "original_fully_qualified_name": "IsBuilt", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Bit ambiguous: used to detect when user didn't build texture but effectively we should check TexID != 0 except that would be backend dependent.." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3750 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesDefault", + "original_fully_qualified_name": "GetGlyphRangesDefault", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "preceding": [ + "// Since 1.92: specifying glyph ranges is only useful/necessary if your backend doesn't support ImGuiBackendFlags_RendererHasTextures!" + ], + "attached": "// Basic Latin, Extended Latin" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3758 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesGreek", + "original_fully_qualified_name": "GetGlyphRangesGreek", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "preceding": [ + "// Helpers to retrieve list of common Unicode ranges (2 value per range, values are inclusive, zero-terminated list)", + "// NB: Make sure that your string are UTF-8 and NOT in your local code page.", + "// Read https://github.com/ocornut/imgui/blob/master/docs/FONTS.md/#about-utf-8-encoding for details.", + "// NB: Consider using ImFontGlyphRangesBuilder to build glyph ranges from textual data." + ], + "attached": "// Default + Greek and Coptic" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3764 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesKorean", + "original_fully_qualified_name": "GetGlyphRangesKorean", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Default + Korean characters" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3765 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesJapanese", + "original_fully_qualified_name": "GetGlyphRangesJapanese", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Default + Hiragana, Katakana, Half-Width, Selection of 2999 Ideographs" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3766 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesChineseFull", + "original_fully_qualified_name": "GetGlyphRangesChineseFull", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Default + Half-Width + Japanese Hiragana/Katakana + full set of about 21000 CJK Unified Ideographs" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3767 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon", + "original_fully_qualified_name": "GetGlyphRangesChineseSimplifiedCommon", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Default + Half-Width + Japanese Hiragana/Katakana + set of 2500 CJK Unified Ideographs for common simplified Chinese" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3768 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesCyrillic", + "original_fully_qualified_name": "GetGlyphRangesCyrillic", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Default + about 400 Cyrillic characters" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3769 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesThai", + "original_fully_qualified_name": "GetGlyphRangesThai", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Default + Thai characters" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3770 + } + }, + { + "name": "ImFontAtlas_GetGlyphRangesVietnamese", + "original_fully_qualified_name": "GetGlyphRangesVietnamese", + "return_type": { + "declaration": "const ImWchar*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImWchar", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Default + Vietnamese characters" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3771 + } + }, + { + "name": "ImFontAtlas_AddCustomRect", + "original_fully_qualified_name": "AddCustomRect", + "return_type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "width", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "height", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_r", + "type": { + "declaration": "ImFontAtlasRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "preceding": [ + "// Register and retrieve custom rectangles", + "// - You can request arbitrary rectangles to be packed into the atlas, for your own purpose.", + "// - Since 1.92.X, packing is done immediately in the function call (previously packing was done during the Build call)", + "// - You can render your pixels into the texture right after calling the AddCustomRect() functions.", + "// - VERY IMPORTANT:", + "// - Texture may be created/resized at any time when calling ImGui or ImFontAtlas functions.", + "// - IT WILL INVALIDATE RECTANGLE DATA SUCH AS UV COORDINATES. Always use latest values from GetCustomRect().", + "// - UV coordinates are associated to the current texture identifier aka 'atlas->TexRef'. Both TexRef and UV coordinates are typically changed at the same time.", + "// - If you render colored output into your custom rectangles: set 'atlas->TexPixelsUseColors = true' as this may help some backends decide of preferred texture format.", + "// - Read docs/FONTS.md for more details about using colorful icons.", + "// - Note: this API may be reworked further in order to facilitate supporting e.g. multi-monitor, varying DPI settings.", + "// - (Pre-1.92 names) ------------> (1.92 names)", + "// - GetCustomRectByIndex() --> Use GetCustomRect()", + "// - CalcCustomRectUV() --> Use GetCustomRect() and read uv0, uv1 fields.", + "// - AddCustomRectRegular() --> Renamed to AddCustomRect()", + "// - AddCustomRectFontGlyph() --> Prefer using custom ImFontLoader inside ImFontConfig", + "// - ImFontAtlasCustomRect --> Renamed to ImFontAtlasRect" + ], + "attached": "// Register a rectangle. Return -1 (ImFontAtlasRectId_Invalid) on error." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3795 + } + }, + { + "name": "ImFontAtlas_RemoveCustomRect", + "original_fully_qualified_name": "RemoveCustomRect", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Unregister a rectangle. Existing pixels will stay in texture until resized / garbage collected." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3796 + } + }, + { + "name": "ImFontAtlas_GetCustomRect", + "original_fully_qualified_name": "GetCustomRect", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_r", + "type": { + "declaration": "ImFontAtlasRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasRect" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// Get rectangle coordinates for current texture. Valid immediately, never store this (read above)!" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3797 + } + }, + { + "name": "ImFontAtlas_AddCustomRectRegular", + "original_fully_qualified_name": "AddCustomRectRegular", + "return_type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// RENAMED in 1.92.X" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3849 + } + }, + { + "name": "ImFontAtlas_GetCustomRectByIndex", + "original_fully_qualified_name": "GetCustomRectByIndex", + "return_type": { + "declaration": "const ImFontAtlasRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasRect", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "id", + "type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// OBSOLETED in 1.92.X" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3850 + } + }, + { + "name": "ImFontAtlas_CalcCustomRectUV", + "original_fully_qualified_name": "CalcCustomRectUV", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "r", + "type": { + "declaration": "const ImFontAtlasRect*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontAtlasRect", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_uv_min", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_uv_max", + "type": { + "declaration": "ImVec2*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec2" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// OBSOLETED in 1.92.X" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3851 + } + }, + { + "name": "ImFontAtlas_AddCustomRectFontGlyph", + "original_fully_qualified_name": "AddCustomRectFontGlyph", + "return_type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "codepoint", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "advance_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "offset", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// OBSOLETED in 1.92.X: Use custom ImFontLoader in ImFontConfig" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3852 + } + }, + { + "name": "ImFontAtlas_AddCustomRectFontGlyphForSize", + "original_fully_qualified_name": "AddCustomRectFontGlyphForSize", + "return_type": { + "declaration": "ImFontAtlasRectId", + "description": { + "kind": "User", + "name": "ImFontAtlasRectId" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontAtlas*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontAtlas" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "codepoint", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "w", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "h", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "advance_x", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "offset", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "ImVec2(0, 0)", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontAtlas", + "comments": { + "attached": "// ADDED AND OBSOLETED in 1.92.X" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3853 + } + }, + { + "name": "ImFontBaked_ClearOutputData", + "original_fully_qualified_name": "ClearOutputData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontBaked", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3890 + } + }, + { + "name": "ImFontBaked_FindGlyph", + "original_fully_qualified_name": "FindGlyph", + "return_type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontBaked", + "comments": { + "attached": "// Return U+FFFD glyph if requested glyph doesn't exists." + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3891 + } + }, + { + "name": "ImFontBaked_FindGlyphNoFallback", + "original_fully_qualified_name": "FindGlyphNoFallback", + "return_type": { + "declaration": "ImFontGlyph*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontGlyph" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontBaked", + "comments": { + "attached": "// Return NULL if glyph doesn't exist" + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3892 + } + }, + { + "name": "ImFontBaked_GetCharAdvance", + "original_fully_qualified_name": "GetCharAdvance", + "return_type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontBaked", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3893 + } + }, + { + "name": "ImFontBaked_IsGlyphLoaded", + "original_fully_qualified_name": "IsGlyphLoaded", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFontBaked", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3894 + } + }, + { + "name": "ImFont_IsGlyphInFont", + "original_fully_qualified_name": "IsGlyphInFont", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3937 + } + }, + { + "name": "ImFont_IsLoaded", + "original_fully_qualified_name": "IsLoaded", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3938 + } + }, + { + "name": "ImFont_GetDebugName", + "original_fully_qualified_name": "GetDebugName", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "attached": "// Fill ImFontConfig::Name." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3939 + } + }, + { + "name": "ImFont_GetFontBaked", + "original_fully_qualified_name": "GetFontBaked", + "return_type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "preceding": [ + "// [Internal] Don't use!", + "// 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.", + "// 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable." + ], + "attached": "// Implied density = -1.0f" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3944 + } + }, + { + "name": "ImFont_GetFontBakedEx", + "original_fully_qualified_name": "GetFontBaked", + "return_type": { + "declaration": "ImFontBaked*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFontBaked" + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "font_size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "density", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1.0f", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "attached": "// Get or create baked data for given size" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3944 + } + }, + { + "name": "ImFont_CalcTextSizeA", + "original_fully_qualified_name": "CalcTextSizeA", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "max_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "attached": "// Implied text_end = NULL, remaining = NULL" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3945 + } + }, + { + "name": "ImFont_CalcTextSizeAEx", + "original_fully_qualified_name": "CalcTextSizeA", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "max_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + }, + { + "name": "remaining", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "attached": "// utf8" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3945 + } + }, + { + "name": "ImFont_CalcWordWrapPosition", + "original_fully_qualified_name": "CalcWordWrapPosition", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3946 + } + }, + { + "name": "ImFont_RenderChar", + "original_fully_qualified_name": "RenderChar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "attached": "// Implied cpu_fine_clip = NULL" + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3947 + } + }, + { + "name": "ImFont_RenderCharEx", + "original_fully_qualified_name": "RenderChar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "cpu_fine_clip", + "type": { + "declaration": "const ImVec4*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImVec4", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3947 + } + }, + { + "name": "ImFont_RenderText", + "original_fully_qualified_name": "RenderText", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "draw_list", + "type": { + "declaration": "ImDrawList*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImDrawList" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "pos", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "col", + "type": { + "declaration": "ImU32", + "description": { + "kind": "User", + "name": "ImU32" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "clip_rect", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_begin", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0.0f", + "is_instance_pointer": false + }, + { + "name": "cpu_fine_clip", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "false", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3948 + } + }, + { + "name": "ImFont_CalcWordWrapPositionA", + "original_fully_qualified_name": "CalcWordWrapPositionA", + "return_type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "scale", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "text_end", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "wrap_width", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 3950 + } + }, + { + "name": "ImFont_ClearOutputData", + "original_fully_qualified_name": "ClearOutputData", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "preceding": [ + "// [Internal] Don't use!" + ] + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3954 + } + }, + { + "name": "ImFont_AddRemapChar", + "original_fully_qualified_name": "AddRemapChar", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "from_codepoint", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "to_codepoint", + "type": { + "declaration": "ImWchar", + "description": { + "kind": "User", + "name": "ImWchar" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "comments": { + "attached": "// Makes 'from_codepoint' character points to 'to_codepoint' glyph." + }, + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3955 + } + }, + { + "name": "ImFont_IsGlyphRangeUnused", + "original_fully_qualified_name": "IsGlyphRangeUnused", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + }, + { + "name": "c_begin", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "c_last", + "type": { + "declaration": "unsigned int", + "description": { + "kind": "Builtin", + "builtin_type": "unsigned_int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImFont", + "is_internal": true, + "source_location": { + "filename": "imgui.h", + "line": 3956 + } + }, + { + "name": "ImGuiViewport_GetCenter", + "original_fully_qualified_name": "GetCenter", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiViewport*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewport", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewport", + "comments": { + "preceding": [ + "// Helpers" + ] + }, + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4041 + } + }, + { + "name": "ImGuiViewport_GetWorkCenter", + "original_fully_qualified_name": "GetWorkCenter", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [ + { + "name": "self", + "type": { + "declaration": "const ImGuiViewport*", + "description": { + "kind": "Pointer", + "is_nullable": false, + "inner_type": { + "kind": "User", + "name": "ImGuiViewport", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": true + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "original_class": "ImGuiViewport", + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4042 + } + }, + { + "name": "ImGui_PushFont", + "original_fully_qualified_name": "ImGui::PushFont", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "font", + "type": { + "declaration": "ImFont*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "User", + "name": "ImFont" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// OBSOLETED in 1.92.0 (from June 2025)" + ] + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4232 + } + }, + { + "name": "ImGui_SetWindowFontScale", + "original_fully_qualified_name": "ImGui::SetWindowFontScale", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "scale", + "type": { + "declaration": "float", + "description": { + "kind": "Builtin", + "builtin_type": "float" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Set font scale factor for current window. Prefer using PushFont(NULL, style.FontSizeBase * factor) or use style.FontScaleMain to scale all windows." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4233 + } + }, + { + "name": "ImGui_ImageImVec4", + "original_fully_qualified_name": "ImGui::Image", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tex_ref", + "type": { + "declaration": "ImTextureRef", + "description": { + "kind": "User", + "name": "ImTextureRef" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "image_size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv0", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "uv1", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "tint_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "border_col", + "type": { + "declaration": "ImVec4", + "description": { + "kind": "User", + "name": "ImVec4" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// OBSOLETED in 1.91.9 (from February 2025)" + ], + "attached": "// <-- 'border_col' was removed in favor of ImGuiCol_ImageBorder. If you use 'tint_col', use ImageWithBg() instead." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4235 + } + }, + { + "name": "ImGui_PushButtonRepeat", + "original_fully_qualified_name": "ImGui::PushButtonRepeat", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "repeat", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// OBSOLETED in 1.91.0 (from July 2024)" + ] + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4237 + } + }, + { + "name": "ImGui_PopButtonRepeat", + "original_fully_qualified_name": "ImGui::PopButtonRepeat", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4238 + } + }, + { + "name": "ImGui_PushTabStop", + "original_fully_qualified_name": "ImGui::PushTabStop", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "tab_stop", + "type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4239 + } + }, + { + "name": "ImGui_PopTabStop", + "original_fully_qualified_name": "ImGui::PopTabStop", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4240 + } + }, + { + "name": "ImGui_GetContentRegionMax", + "original_fully_qualified_name": "ImGui::GetContentRegionMax", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Content boundaries max (e.g. window boundaries including scrolling, or current column boundaries). You should never need this. Always use GetCursorScreenPos() and GetContentRegionAvail()!" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4241 + } + }, + { + "name": "ImGui_GetWindowContentRegionMin", + "original_fully_qualified_name": "ImGui::GetWindowContentRegionMin", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Content boundaries min for the window (roughly (0,0)-Scroll), in window-local coordinates. You should never need this. Always use GetCursorScreenPos() and GetContentRegionAvail()!" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4242 + } + }, + { + "name": "ImGui_GetWindowContentRegionMax", + "original_fully_qualified_name": "ImGui::GetWindowContentRegionMax", + "return_type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Content boundaries max for the window (roughly (0,0)+Size-Scroll), in window-local coordinates. You should never need this. Always use GetCursorScreenPos() and GetContentRegionAvail()!" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4243 + } + }, + { + "name": "ImGui_BeginChildFrame", + "original_fully_qualified_name": "ImGui::BeginChildFrame", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// OBSOLETED in 1.90.0 (from September 2023)" + ], + "attached": "// Implied window_flags = 0" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4245 + } + }, + { + "name": "ImGui_BeginChildFrameEx", + "original_fully_qualified_name": "ImGui::BeginChildFrame", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "id", + "type": { + "declaration": "ImGuiID", + "description": { + "kind": "User", + "name": "ImGuiID" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "size", + "type": { + "declaration": "ImVec2", + "description": { + "kind": "User", + "name": "ImVec2" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "window_flags", + "type": { + "declaration": "ImGuiWindowFlags", + "description": { + "kind": "User", + "name": "ImGuiWindowFlags" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "0", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4245 + } + }, + { + "name": "ImGui_EndChildFrame", + "original_fully_qualified_name": "ImGui::EndChildFrame", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4246 + } + }, + { + "name": "ImGui_ShowStackToolWindow", + "original_fully_qualified_name": "ImGui::ShowStackToolWindow", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [ + { + "name": "p_open", + "type": { + "declaration": "bool*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "bool" + } + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "NULL", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "//inline bool BeginChild(const char* str_id, const ImVec2& size_arg, bool borders, ImGuiWindowFlags window_flags){ return BeginChild(str_id, size_arg, borders ? ImGuiChildFlags_Borders : ImGuiChildFlags_None, window_flags); } // Unnecessary as true == ImGuiChildFlags_Borders", + "//inline bool BeginChild(ImGuiID id, const ImVec2& size_arg, bool borders, ImGuiWindowFlags window_flags) { return BeginChild(id, size_arg, borders ? ImGuiChildFlags_Borders : ImGuiChildFlags_None, window_flags); } // Unnecessary as true == ImGuiChildFlags_Borders" + ] + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4249 + } + }, + { + "name": "ImGui_ComboObsolete", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_callback", + "type": { + "declaration": "bool (*old_callback)(void* user_data, int idx, const char** out_text)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_text", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "old_callback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + { + "kind": "Type", + "name": "out_text", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied popup_max_height_in_items = -1" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4250 + } + }, + { + "name": "ImGui_ComboObsoleteEx", + "original_fully_qualified_name": "ImGui::Combo", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_callback", + "type": { + "declaration": "bool (*old_callback)(void* user_data, int idx, const char** out_text)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_text", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "old_callback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + { + "kind": "Type", + "name": "out_text", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "popup_max_height_in_items", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4250 + } + }, + { + "name": "ImGui_ListBoxObsolete", + "original_fully_qualified_name": "ImGui::ListBox", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_callback", + "type": { + "declaration": "bool (*old_callback)(void* user_data, int idx, const char** out_text)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_text", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "old_callback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + { + "kind": "Type", + "name": "out_text", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ], + "is_default_argument_helper": true, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "attached": "// Implied height_in_items = -1" + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4251 + } + }, + { + "name": "ImGui_ListBoxObsoleteEx", + "original_fully_qualified_name": "ImGui::ListBox", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "label", + "type": { + "declaration": "const char*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "current_item", + "type": { + "declaration": "int*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "old_callback", + "type": { + "declaration": "bool (*old_callback)(void* user_data, int idx, const char** out_text)", + "type_details": { + "flavour": "function_pointer", + "return_type": { + "declaration": "bool", + "description": { + "kind": "Builtin", + "builtin_type": "bool" + } + }, + "arguments": [ + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "idx", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "out_text", + "type": { + "declaration": "const char**", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + } + ] + }, + "description": { + "kind": "Type", + "name": "old_callback", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Function", + "return_type": { + "kind": "Builtin", + "builtin_type": "bool" + }, + "parameters": [ + { + "kind": "Type", + "name": "user_data", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + { + "kind": "Type", + "name": "idx", + "inner_type": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + { + "kind": "Type", + "name": "out_text", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "char", + "storage_classes": [ + "const" + ] + } + } + } + } + ] + } + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "user_data", + "type": { + "declaration": "void*", + "description": { + "kind": "Pointer", + "inner_type": { + "kind": "Builtin", + "builtin_type": "void" + } + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "items_count", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "is_instance_pointer": false + }, + { + "name": "height_in_items", + "type": { + "declaration": "int", + "description": { + "kind": "Builtin", + "builtin_type": "int" + } + }, + "is_array": false, + "is_varargs": false, + "default_value": "-1", + "is_instance_pointer": false + } + ], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4251 + } + }, + { + "name": "ImGui_SetItemAllowOverlap", + "original_fully_qualified_name": "ImGui::SetItemAllowOverlap", + "return_type": { + "declaration": "void", + "description": { + "kind": "Builtin", + "builtin_type": "void" + } + }, + "arguments": [], + "is_default_argument_helper": false, + "is_manual_helper": false, + "is_imstr_helper": false, + "has_imstr_helper": false, + "is_unformatted_helper": false, + "is_static": false, + "comments": { + "preceding": [ + "// OBSOLETED in 1.89.7 (from June 2023)" + ], + "attached": "// Use SetNextItemAllowOverlap() before item." + }, + "conditionals": [ + { + "condition": "ifndef", + "expression": "IMGUI_DISABLE_OBSOLETE_FUNCTIONS" + } + ], + "is_internal": false, + "source_location": { + "filename": "imgui.h", + "line": 4253 + } + } + ] +} \ No newline at end of file diff --git a/src/generate.zig b/src/generate.zig index 99cabea..3f86f00 100644 --- a/src/generate.zig +++ b/src/generate.zig @@ -8,6 +8,37 @@ const DeclarationKind = enum { }; const Declarations = std.StringArrayHashMap(DeclarationKind); + +const Symbols = struct { + public: std.StringArrayHashMap(void), + front_buf: std.StringArrayHashMap(void), + + pub fn init(allocator: Allocator) @This() { + return .{ + .public = .init(allocator), + .front_buf = .init(allocator), + }; + } + + pub fn deinit(self: *@This()) void { + self.public.deinit(); + self.front_buf.deinit(); + } + + /// Returns true if there's already a public symbol with this name. + pub fn put(self: *@This(), name: []const u8) !bool { + const trimmed = std.mem.trimRight(u8, name, "_"); + if (self.public.contains(trimmed)) return false; + try self.front_buf.put(trimmed, {}); + return true; + } + + pub fn makePublic(self: *@This()) void { + std.mem.swap(@FieldType(@This(), "public"), &self.public, &self.front_buf); + self.front_buf.clearRetainingCapacity(); + } +}; + const max_size = 5000000; // The header type we'll parse from JSON. Fields are only included as needed. @@ -55,6 +86,7 @@ const Header = struct { const Struct = struct { name: []const u8, + is_internal: bool, is_anonymous: bool, kind: enum { @"struct", @"union" }, forward_declaration: bool, @@ -66,7 +98,7 @@ const Header = struct { is_anonymous: bool, type: Type, width: ?usize = null, - default_value: ?std.json.Value = null, + default_value: ?[]const u8 = null, conditionals: []const Conditional = &.{}, }; }; @@ -155,6 +187,7 @@ pub fn main() !void { const out_path = args.next().?; const prefix_path = args.next(); const postfix_path = args.next(); + const internal_path = args.next(); std.debug.assert(args.next() == null); const out = try std.fs.cwd().createFile(out_path, .{}); @@ -171,45 +204,36 @@ pub fn main() !void { try writer.writeAll("\n// End of prefix\n\n"); } + // Build a list of symbols so we can skip duplicates of public symbols in the internal headers + var symbols: Symbols = .init(allocator); + defer symbols.deinit(); + // Write the source - { - const source = try std.fs.cwd().readFileAlloc(allocator, in_path, max_size); - defer allocator.free(source); + const main_source = try std.fs.cwd().readFileAlloc(allocator, in_path, max_size); + defer allocator.free(main_source); + try writeSource( + allocator, + main_source, + writer, + &symbols, + false, + ); + symbols.makePublic(); - const header = try std.json.parseFromSlice(Header, allocator, source, .{ - .ignore_unknown_fields = true, - }); - defer header.deinit(); + // Write the internal source, if supplied + if (internal_path) |p| { + const internal_source = try std.fs.cwd().readFileAlloc(allocator, p, max_size); + defer allocator.free(internal_source); - // We need the list of declarations up front. - var declarations = try getDeclarations(allocator, &header.value); - defer declarations.deinit(); - - // Write all defines as private constants. - try writeDefines(writer, &header.value); - - // Write all typedefs as private constants. - try writeTypedefs(writer, &header.value, &declarations); - - // Write all cimgui functions as private extern functions. - try writeExternFunctions(writer, &header.value, &declarations); - - // Alias cimgui free functions under Zig friendly names. - try writeFreeFunctions(writer, &header.value); - - // Get a list of cimgui methods. These were already written as externs, and can be aliased - // when we write their respective types. - var methods = try Methods.get(allocator, &header.value); - defer methods.deinit(allocator); - - // Write cimgui enums as Zig enums. - try writeEnums(allocator, writer, &header.value); - - // Write cimgui structs as Zig structs and unions. - try writeStructs(writer, &header.value, &declarations, &methods); - - // Write helpers used by the other generated code. - try writeHelpers(writer); + try writer.writeAll("pub const internal = struct {\n"); + try writeSource( + allocator, + internal_source, + writer, + &symbols, + true, + ); + try writer.writeAll("};\n"); } // Write the postfix @@ -224,12 +248,61 @@ pub fn main() !void { try writer.flush(); } +fn writeSource( + allocator: Allocator, + source: []const u8, + writer: *std.Io.Writer, + symbols: *Symbols, + internal: bool, +) !void { + const header = try std.json.parseFromSlice(Header, allocator, source, .{ + .ignore_unknown_fields = true, + }); + defer header.deinit(); + + // We need the list of declarations up front. + var declarations = try getDeclarations(allocator, &header.value); + defer declarations.deinit(); + + // Write all defines as private constants. + try writeDefines(writer, internal, symbols, &header.value); + + // Write all typedefs as private constants. + try writeTypedefs(writer, &header.value, symbols, &declarations); + + // Write all cimgui functions as private extern functions. + try writeExternFunctions(writer, &header.value, symbols, &declarations); + + // Alias cimgui free functions under Zig friendly names. + try writeFreeFunctions(writer, &header.value, symbols); + + // Get a list of cimgui methods. These were already written as externs, and can be aliased + // when we write their respective types. + var methods = try Methods.get(allocator, &header.value); + defer methods.deinit(allocator); + + // Write cimgui enums as Zig enums. + try writeEnums(allocator, writer, internal, &header.value, symbols); + + // Write cimgui structs as Zig structs and unions. + try writeStructs(writer, &header.value, &declarations, &methods, symbols); + + // Write helpers used by the other generated code. We skip this for the internal header + // since we're going to concatenate it with the main header, so this stuff will already be + // available. + if (!internal) { + try writeHelpers(writer); + } +} + fn getDeclarations(allocator: Allocator, header: *const Header) !Declarations { var declarations = Declarations.init(allocator); errdefer declarations.deinit(); for (header.structs) |ty| { if (skip(ty.conditionals)) continue; + const trimmed = std.mem.trimRight(u8, ty.name, "_"); + var kind: DeclarationKind = .normal; if (ty.forward_declaration) { if (std.mem.eql(u8, "ImDrawData", ty.name)) { @@ -259,12 +332,10 @@ fn getDeclarations(allocator: Allocator, header: *const Header) !Declarations { }; } - const trimmed = std.mem.trimRight(u8, ty.name, "_"); try declarations.put(trimmed, kind); } for (header.enums) |e| { - if (e.is_internal) continue; if (skip(e.conditionals)) continue; const trimmed = std.mem.trimRight(u8, e.name, "_"); @@ -274,26 +345,36 @@ fn getDeclarations(allocator: Allocator, header: *const Header) !Declarations { return declarations; } -fn writeDefines(writer: anytype, header: *const Header) !void { +fn writeDefines(writer: anytype, internal: bool, symbols: *Symbols, header: *const Header) !void { + // We skip defines from the internal namespace for now + if (internal) return; + for (header.defines) |define| { - if (define.is_internal) continue; + if (define.is_internal != internal) continue; if (skip(define.conditionals)) continue; if (define.content) |content| { - if (std.mem.startsWith(u8, content, "(")) { - const end = std.mem.indexOfScalar(u8, content, ')').?; - const ty = content[1..end]; - const val = content[end + 1 ..]; - try writer.print("const {s}: ", .{define.name}); - try writeTypeName(writer, ty); - try writer.print(" = {s};\n", .{val}); - } else { - try writer.print("const {s} = {s};\n", .{ define.name, content }); + if (try symbols.put(define.name)) { + if (std.mem.startsWith(u8, content, "(")) { + const end = std.mem.indexOfScalar(u8, content, ')').?; + const ty = content[1..end]; + const val = content[end + 1 ..]; + try writer.print("const {s}: ", .{define.name}); + try writeTypeName(writer, ty); + try writer.print(" = {s};\n", .{val}); + } else { + try writer.print("const {s} = {s};\n", .{ define.name, content }); + } } } } } -fn writeTypedefs(writer: anytype, header: *const Header, declarations: *const Declarations) !void { +fn writeTypedefs( + writer: anytype, + header: *const Header, + symbols: *Symbols, + declarations: *const Declarations, +) !void { for (header.typedefs) |typedef| { // Skip typedefs skipped by the preprocessor if (skip(typedef.conditionals)) continue; @@ -306,41 +387,46 @@ fn writeTypedefs(writer: anytype, header: *const Header, declarations: *const De std.mem.eql(u8, typedef.name, typedef.type.declaration.?)) continue; // Write the typedef prefix - try writer.writeAll("const "); - try writeTypeName(writer, typedef.name); - try writer.writeAll(" = "); - try writeType(writer, typedef.type, declarations, .{}); - try writer.writeAll(";\n"); + if (try symbols.put(typedef.name)) { + try writer.writeAll("const "); + try writeTypeName(writer, typedef.name); + try writer.writeAll(" = "); + try writeType(writer, typedef.type, declarations, .{}); + try writer.writeAll(";\n"); + } } } fn writeExternFunctions( writer: anytype, header: *const Header, + symbols: *Symbols, declarations: *const Declarations, ) !void { for (header.functions) |function| { if (skip(function.conditionals)) continue; if (argsContainsVaList(function.arguments)) continue; - try writer.print("extern fn {s}(", .{function.name}); - for (function.arguments) |argument| { - if (argument.type) |ty| { - std.debug.assert(!argument.is_varargs); - try writeType(writer, ty, declarations, .{ - .is_instance_pointer = argument.is_instance_pointer, - .is_argument = true, - .default_null = if (argument.default_value) |d| std.mem.eql(u8, d, "NULL") else false, - }); - } else { - std.debug.assert(argument.is_varargs); - try writer.writeAll("..."); + if (try symbols.put(function.name)) { + try writer.print("extern fn {s}(", .{function.name}); + for (function.arguments) |argument| { + if (argument.type) |ty| { + std.debug.assert(!argument.is_varargs); + try writeType(writer, ty, declarations, .{ + .is_instance_pointer = argument.is_instance_pointer, + .is_argument = true, + .default_null = if (argument.default_value) |d| std.mem.eql(u8, d, "NULL") else false, + }); + } else { + std.debug.assert(argument.is_varargs); + try writer.writeAll("..."); + } + try writer.writeAll(", "); } - try writer.writeAll(", "); + try writer.writeAll(") callconv(.c) "); + try writeType(writer, function.return_type, declarations, .{ .is_result = true }); + try writer.writeAll(";\n"); } - try writer.writeAll(") callconv(.c) "); - try writeType(writer, function.return_type, declarations, .{ .is_result = true }); - try writer.writeAll(";\n"); } } @@ -355,15 +441,17 @@ fn argsContainsVaList(arguments: []const Header.Function.Argument) bool { return false; } -fn writeFreeFunctions(writer: anytype, header: *const Header) !void { +fn writeFreeFunctions(writer: anytype, header: *const Header, symbols: *Symbols) !void { for (header.functions) |function| { if (skip(function.conditionals)) continue; if (function.original_class != null) continue; if (argsContainsVaList(function.arguments)) continue; - try writer.writeAll("pub const "); - try writeFunctionName(writer, function.name); - try writer.print(" = {s};\n", .{function.name}); + if (try symbols.put(function.name)) { + try writer.writeAll("pub const "); + try writeFunctionName(writer, function.name); + try writer.print(" = {s};\n", .{function.name}); + } } } @@ -406,24 +494,31 @@ const Methods = struct { } }; -fn writeEnums(allocator: Allocator, writer: anytype, header: *const Header) !void { +fn writeEnums( + allocator: Allocator, + writer: anytype, + internal: bool, + header: *const Header, + symbols: *Symbols, +) !void { for (header.enums) |e| { - if (e.is_internal) continue; if (skip(e.conditionals)) continue; - try writer.writeAll("pub const "); - try writeTypeName(writer, e.name); - try writer.writeAll(" = "); + if (try symbols.put(e.name)) { + try writer.writeAll("pub const "); + try writeTypeName(writer, e.name); + try writer.writeAll(" = "); - if (e.is_flags_enum) { - try writeFlagsEnum(writer, e); - } else { - try writeNormalEnum(allocator, writer, e); + if (e.is_flags_enum) { + try writeFlagsEnum(writer, internal, e); + } else { + try writeNormalEnum(allocator, writer, internal, e); + } } } } -fn writeFlagsEnum(writer: anytype, e: Header.Enum) !void { +fn writeFlagsEnum(writer: anytype, internal: bool, e: Header.Enum) !void { const backing, const backing_bits = switch (e.storage_type.declaration) { .int => .{ "c_int", @typeInfo(c_int).int.bits }, .ImU8 => .{ "u8", 8 }, @@ -432,9 +527,9 @@ fn writeFlagsEnum(writer: anytype, e: Header.Enum) !void { var current_offset: usize = 0; var padding_i: usize = 0; for (e.elements) |element| { - // Skip internal elements, and elements discarded by preprocessor + // Skip elements without matching visibility, and elements discarded by preprocessor if (skip(element.conditionals)) continue; - if (element.is_internal) continue; + if (element.is_internal != internal) continue; if (element.value == 0) continue; // Calculate the offset of this element @@ -471,7 +566,7 @@ fn writeFlagsEnum(writer: anytype, e: Header.Enum) !void { try writer.writeAll("};\n"); } -fn writeNormalEnum(allocator: Allocator, writer: anytype, e: Header.Enum) !void { +fn writeNormalEnum(allocator: Allocator, writer: anytype, internal: bool, e: Header.Enum) !void { var values = std.AutoArrayHashMap(i64, void).init(allocator); defer values.deinit(); @@ -484,8 +579,8 @@ fn writeNormalEnum(allocator: Allocator, writer: anytype, e: Header.Enum) !void // Write elements for (e.elements) |element| { - // Skip internal and count - if (element.is_internal) continue; + // Skip non visible elements and count elements + if (element.is_internal != internal) continue; if (element.is_count) continue; if (skip(element.conditionals)) continue; @@ -517,6 +612,7 @@ fn writeStructs( header: *const Header, declarations: *const Declarations, methods: *const Methods, + symbols: *Symbols, ) !void { for (header.structs) |ty| { // Skip structs skipped by the preprocessor. We don't skip structs marked as internal, @@ -528,56 +624,79 @@ fn writeStructs( const decl_kind = declarations.get(ty.name).?; if (decl_kind == .import) continue; - // Write the struct - try writer.writeAll("pub const "); - try writeTypeName(writer, ty.name); - try writer.writeAll(" = "); + if (try symbols.put(ty.name)) { + // Write the struct + try writer.writeAll("pub const "); + try writeTypeName(writer, ty.name); + try writer.writeAll(" = "); - // If we're opaque, don't try to fill out the struct fields - if (decl_kind == .@"opaque") { - try writer.writeAll("opaque {};\n"); - continue; - } - - // Declare the struct or union - switch (ty.kind) { - .@"struct" => try writer.writeAll("extern struct {\n"), - .@"union" => try writer.writeAll("extern union {\n"), - } - - // Fill in the fields - for (ty.fields) |field| { - // Skip fields skipped by the preprocessor. - if (skip(field.conditionals)) continue; - - // Not yet used, but when it is we want to start using it. Safe to disable this assert - // if you're just trying to get things working with a different version. - if (field.default_value != null) @panic("unimplemented"); - - // Write the field. - try writer.writeAll(" "); - if (field.is_anonymous) { - try writer.writeAll("data"); - } else { - try writeFieldName(writer, field.name); + // If we're opaque, don't try to fill out the struct fields + if (decl_kind == .@"opaque") { + try writer.writeAll("opaque {};\n"); + continue; } - try writer.writeAll(": "); - try writeType(writer, field.type, declarations, .{}); - try writer.writeAll(",\n"); - } - // Alias all relevant methods into the type. - const method_names = methods.types.getPtr(ty.name).?; - for (method_names.items) |name| { - try writer.writeAll(" pub const "); - try writeFunctionName(writer, name[ty.name.len + 1 ..]); - try writer.print(" = {s};\n", .{name}); - } + // Declare the struct or union + switch (ty.kind) { + .@"struct" => try writer.writeAll("extern struct {\n"), + .@"union" => try writer.writeAll("extern union {\n"), + } - try writer.writeAll("};\n"); + // Fill in the fields + for (ty.fields) |field| { + // Skip fields skipped by the preprocessor. + if (skip(field.conditionals)) continue; + + // Write the field. + try writer.writeAll(" "); + if (field.is_anonymous) { + try writer.writeAll("data"); + } else { + try writeFieldName(writer, field.name); + } + try writer.writeAll(": "); + try writeType(writer, field.type, declarations, .{}); + if (field.default_value) |v| { + try writer.writeAll(" = "); + try writeValue(writer, v); + } + try writer.writeAll(",\n"); + } + + // Alias all relevant methods into the type. + const method_names = methods.types.getPtr(ty.name).?; + for (method_names.items) |name| { + try writer.writeAll(" pub const "); + try writeFunctionName(writer, name[ty.name.len + 1 ..]); + try writer.print(" = {s};\n", .{name}); + } + + try writer.writeAll("};\n"); + } } } +pub fn writeValue(writer: anytype, value: []const u8) !void { + // Strip the `f` postfix off of floats + float: { + if (value.len > 0 and + value[value.len - 1] == 'f' and + value[0] >= '0' and + value[0] <= '9') + { + switch (value[0]) { + '0'...'9' => {}, + else => break :float, + } + try writer.writeAll(value[0 .. value.len - 1]); + return; + } + } + + // Write everything else as is + try writer.writeAll(value); +} + fn writeHelpers(writer: anytype) !void { try writer.writeAll( \\fn toUsize(v: anytype) usize { @@ -836,6 +955,12 @@ fn skip(conditionals: []const Header.Conditional) bool { if (std.mem.eql(u8, conditional.expression, "defined(VK_USE_PLATFORM_WIN32_KHR)&&!defined(NOMINMAX)")) break :b true; if (std.mem.eql(u8, conditional.expression, "IMGUI_IMPL_VULKAN_HAS_DYNAMIC_RENDERING")) break :b true; if (std.mem.eql(u8, conditional.expression, "defined(VK_VERSION_1_3)|| defined(VK_KHR_dynamic_rendering)")) break :b true; + if (std.mem.eql(u8, conditional.expression, "IMGUI_HAS_DOCK")) break :b true; + if (std.mem.eql(u8, conditional.expression, "IMGUI_ENABLE_SSE")) break :b true; + if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS")) break :b true; + if (std.mem.eql(u8, conditional.expression, "IMGUI_ENABLE_STB_TRUETYPE")) break :b true; + if (std.mem.eql(u8, conditional.expression, "IMGUI_ENABLE_FREETYPE")) break :b true; + if (std.mem.eql(u8, conditional.expression, "IMGUI_ENABLE_TEST_ENGINE")) break :b true; // False conditionals if (std.mem.eql(u8, conditional.expression, "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT")) break :b false; @@ -854,6 +979,9 @@ fn skip(conditionals: []const Header.Conditional) bool { if (std.mem.eql(u8, conditional.expression, "IMGUI_HAS_IMSTR")) break :b false; if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_DEBUG_TOOLS")) break :b false; if (std.mem.eql(u8, conditional.expression, "ImTextureID_Invalid")) break :b false; + if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS")) break :b false; + if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_FILE_FUNCTIONS")) break :b false; + if (std.mem.eql(u8, conditional.expression, "IMGUI_STB_NAMESPACE")) break :b false; std.debug.panic("unexpected preprocessor conditional: {s}", .{conditional.expression}); }; @@ -974,7 +1102,13 @@ fn writeFunctionName(writer: anytype, raw: []const u8) !void { // Imgui prefixes { - const prefixes: []const []const u8 = &.{ "cImGui_ImplVulkan", "cImGui_ImplSDL3", "ImGui", "Im" }; + const prefixes: []const []const u8 = &.{ + "cImGui_ImplVulkan", + "cImGui_ImplSDL3", + "ImGui", + "Im", + "cIm", + }; for (prefixes) |prefix| { if (std.mem.startsWith(u8, name, prefix)) { name = name[prefix.len..];