imgui_internal.h
Go to the documentation of this file.
1 // dear imgui, v1.67 WIP
2 // (internal structures/api)
3 
4 // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
5 // Set:
6 // #define IMGUI_DEFINE_MATH_OPERATORS
7 // To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
8 
9 /*
10 
11 Index of this file:
12 // Header mess
13 // Forward declarations
14 // STB libraries includes
15 // Context pointer
16 // Generic helpers
17 // Misc data structures
18 // Main imgui context
19 // Tab bar, tab item
20 // Internal API
21 
22 */
23 
24 #pragma once
25 
26 //-----------------------------------------------------------------------------
27 // Header mess
28 //-----------------------------------------------------------------------------
29 
30 #ifndef IMGUI_VERSION
31 #error Must include imgui.h before imgui_internal.h
32 #endif
33 
34 #include <stdio.h> // FILE*
35 #include <stdlib.h> // NULL, malloc, free, qsort, atoi, atof
36 #include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
37 #include <limits.h> // INT_MIN, INT_MAX
38 
39 #ifdef _MSC_VER
40 #pragma warning (push)
41 #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)
42 #endif
43 
44 #ifdef __clang__
45 #pragma clang diagnostic push
46 #pragma clang diagnostic ignored "-Wunused-function" // for stb_textedit.h
47 #pragma clang diagnostic ignored "-Wmissing-prototypes" // for stb_textedit.h
48 #pragma clang diagnostic ignored "-Wold-style-cast"
49 #endif
50 
51 //-----------------------------------------------------------------------------
52 // Forward declarations
53 //-----------------------------------------------------------------------------
54 
55 struct ImRect; // An axis-aligned rectangle (2 points)
56 struct ImDrawDataBuilder; // Helper to build a ImDrawData instance
57 struct ImDrawListSharedData; // Data shared between all ImDrawList instances
58 struct ImGuiColorMod; // Stacked color modifier, backup of modified data so we can restore it
59 struct ImGuiColumnData; // Storage data for a single column
60 struct ImGuiColumnsSet; // Storage data for a columns set
61 struct ImGuiContext; // Main imgui context
62 struct ImGuiGroupData; // Stacked storage data for BeginGroup()/EndGroup()
63 struct ImGuiInputTextState; // Internal state of the currently focused/edited text input box
64 struct ImGuiItemHoveredDataBackup; // Backup and restore IsItemHovered() internal data
65 struct ImGuiMenuColumns; // Simple column measurement, currently used for MenuItem() only
66 struct ImGuiNavMoveResult; // Result of a directional navigation move query result
67 struct ImGuiNextWindowData; // Storage for SetNexWindow** functions
68 struct ImGuiPopupRef; // Storage for current popup stack
69 struct ImGuiSettingsHandler; // Storage for one type registered in the .ini file
70 struct ImGuiStyleMod; // Stacked style modifier, backup of modified data so we can restore it
71 struct ImGuiTabBar; // Storage for a tab bar
72 struct ImGuiTabItem; // Storage for a tab item (within a tab bar)
73 struct ImGuiWindow; // Storage for one window
74 struct ImGuiWindowTempData; // Temporary storage for one window (that's the data which in theory we could ditch at the end of the frame)
75 struct ImGuiWindowSettings; // Storage for window settings stored in .ini file (we keep one of those even if the actual window wasn't instanced during this session)
76 
77 // Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.
78 typedef int ImGuiLayoutType; // -> enum ImGuiLayoutType_ // Enum: Horizontal or vertical
79 typedef int ImGuiButtonFlags; // -> enum ImGuiButtonFlags_ // Flags: for ButtonEx(), ButtonBehavior()
80 typedef int ImGuiItemFlags; // -> enum ImGuiItemFlags_ // Flags: for PushItemFlag()
81 typedef int ImGuiItemStatusFlags; // -> enum ImGuiItemStatusFlags_ // Flags: for DC.LastItemStatusFlags
82 typedef int ImGuiNavHighlightFlags; // -> enum ImGuiNavHighlightFlags_ // Flags: for RenderNavHighlight()
83 typedef int ImGuiNavDirSourceFlags; // -> enum ImGuiNavDirSourceFlags_ // Flags: for GetNavInputAmount2d()
84 typedef int ImGuiNavMoveFlags; // -> enum ImGuiNavMoveFlags_ // Flags: for navigation requests
85 typedef int ImGuiSeparatorFlags; // -> enum ImGuiSeparatorFlags_ // Flags: for Separator() - internal
86 typedef int ImGuiSliderFlags; // -> enum ImGuiSliderFlags_ // Flags: for SliderBehavior()
87 typedef int ImGuiDragFlags; // -> enum ImGuiDragFlags_ // Flags: for DragBehavior()
88 
89 //-------------------------------------------------------------------------
90 // STB libraries includes
91 //-------------------------------------------------------------------------
92 
93 namespace ImGuiStb
94 {
95 
96 #undef STB_TEXTEDIT_STRING
97 #undef STB_TEXTEDIT_CHARTYPE
98 #define STB_TEXTEDIT_STRING ImGuiInputTextState
99 #define STB_TEXTEDIT_CHARTYPE ImWchar
100 #define STB_TEXTEDIT_GETWIDTH_NEWLINE -1.0f
101 #include "imstb_textedit.h"
102 
103 } // namespace ImGuiStb
104 
105 //-----------------------------------------------------------------------------
106 // Context pointer
107 //-----------------------------------------------------------------------------
108 
109 #ifndef GImGui
110 extern IMGUI_API ImGuiContext* GImGui; // Current implicit ImGui context pointer
111 #endif
112 
113 //-----------------------------------------------------------------------------
114 // Generic helpers
115 //-----------------------------------------------------------------------------
116 
117 #define IM_PI 3.14159265358979323846f
118 #ifdef _WIN32
119 #define IM_NEWLINE "\r\n" // Play it nice with Windows users (2018/05 news: Microsoft announced that Notepad will finally display Unix-style carriage returns!)
120 #else
121 #define IM_NEWLINE "\n"
122 #endif
123 #define IMGUI_DEBUG_LOG(_FMT,...) printf("[%05d] " _FMT, GImGui->FrameCount, __VA_ARGS__)
124 #define IM_STATIC_ASSERT(_COND) typedef char static_assertion_##__line__[(_COND)?1:-1]
125 #define IM_F32_TO_INT8_UNBOUND(_VAL) ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f))) // Unsaturated, for display purpose
126 #define IM_F32_TO_INT8_SAT(_VAL) ((int)(ImSaturate(_VAL) * 255.0f + 0.5f)) // Saturated, always output 0..255
127 
128 // Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
129 #ifdef _MSC_VER
130 #define IMGUI_CDECL __cdecl
131 #else
132 #define IMGUI_CDECL
133 #endif
134 
135 // Helpers: UTF-8 <> wchar
136 IMGUI_API int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count
137 IMGUI_API int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // read one character. return input UTF-8 bytes count
138 IMGUI_API int ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL); // return input UTF-8 bytes count
139 IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count)
140 IMGUI_API int ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end); // return number of bytes to express one char in UTF-8
141 IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string in UTF-8
142 
143 // Helpers: Misc
144 IMGUI_API ImU32 ImHash(const void* data, int data_size, ImU32 seed = 0); // Pass data_size==0 for zero-terminated strings
145 IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* file_open_mode, size_t* out_file_size = NULL, int padding_bytes = 0);
146 IMGUI_API FILE* ImFileOpen(const char* filename, const char* file_open_mode);
147 static inline bool ImCharIsBlankA(char c) { return c == ' ' || c == '\t'; }
148 static inline bool ImCharIsBlankW(unsigned int c) { return c == ' ' || c == '\t' || c == 0x3000; }
149 static inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; }
150 static inline int ImUpperPowerOfTwo(int v) { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
151 #define ImQsort qsort
152 
153 // Helpers: Geometry
154 IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
155 IMGUI_API bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
156 IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
157 IMGUI_API void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
158 IMGUI_API ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy);
159 
160 // Helpers: String
161 IMGUI_API int ImStricmp(const char* str1, const char* str2);
162 IMGUI_API int ImStrnicmp(const char* str1, const char* str2, size_t count);
163 IMGUI_API void ImStrncpy(char* dst, const char* src, size_t count);
164 IMGUI_API char* ImStrdup(const char* str);
165 IMGUI_API char* ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str);
166 IMGUI_API const char* ImStrchrRange(const char* str_begin, const char* str_end, char c);
167 IMGUI_API int ImStrlenW(const ImWchar* str);
168 IMGUI_API const char* ImStreolRange(const char* str, const char* str_end); // End end-of-line
169 IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line
170 IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);
171 IMGUI_API void ImStrTrimBlanks(char* str);
172 IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
173 IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
174 IMGUI_API const char* ImParseFormatFindStart(const char* format);
175 IMGUI_API const char* ImParseFormatFindEnd(const char* format);
176 IMGUI_API const char* ImParseFormatTrimDecorations(const char* format, char* buf, int buf_size);
177 IMGUI_API int ImParseFormatPrecision(const char* format, int default_value);
178 
179 // Helpers: ImVec2/ImVec4 operators
180 // We are keeping those disabled by default so they don't leak in user space, to allow user enabling implicit cast operators between ImVec2 and their own types (using IM_VEC2_CLASS_EXTRA etc.)
181 // We unfortunately don't have a unary- operator for ImVec2 because this would needs to be defined inside the class itself.
182 #ifdef IMGUI_DEFINE_MATH_OPERATORS
183 static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x*rhs, lhs.y*rhs); }
184 static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x/rhs, lhs.y/rhs); }
185 static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x+rhs.x, lhs.y+rhs.y); }
186 static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x-rhs.x, lhs.y-rhs.y); }
187 static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x*rhs.x, lhs.y*rhs.y); }
188 static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x/rhs.x, lhs.y/rhs.y); }
189 static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs) { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; }
190 static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs) { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; }
191 static inline ImVec2& operator*=(ImVec2& lhs, const float rhs) { lhs.x *= rhs; lhs.y *= rhs; return lhs; }
192 static inline ImVec2& operator/=(ImVec2& lhs, const float rhs) { lhs.x /= rhs; lhs.y /= rhs; return lhs; }
193 static inline ImVec4 operator+(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x+rhs.x, lhs.y+rhs.y, lhs.z+rhs.z, lhs.w+rhs.w); }
194 static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x-rhs.x, lhs.y-rhs.y, lhs.z-rhs.z, lhs.w-rhs.w); }
195 static inline ImVec4 operator*(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x*rhs.x, lhs.y*rhs.y, lhs.z*rhs.z, lhs.w*rhs.w); }
196 #endif
197 
198 // Helpers: Maths
199 // - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)
200 #ifndef IMGUI_DISABLE_MATH_FUNCTIONS
201 static inline float ImFabs(float x) { return fabsf(x); }
202 static inline float ImSqrt(float x) { return sqrtf(x); }
203 static inline float ImPow(float x, float y) { return powf(x, y); }
204 static inline double ImPow(double x, double y) { return pow(x, y); }
205 static inline float ImFmod(float x, float y) { return fmodf(x, y); }
206 static inline double ImFmod(double x, double y) { return fmod(x, y); }
207 static inline float ImCos(float x) { return cosf(x); }
208 static inline float ImSin(float x) { return sinf(x); }
209 static inline float ImAcos(float x) { return acosf(x); }
210 static inline float ImAtan2(float y, float x) { return atan2f(y, x); }
211 static inline double ImAtof(const char* s) { return atof(s); }
212 static inline float ImFloorStd(float x) { return floorf(x); } // we already uses our own ImFloor() { return (float)(int)v } internally so the standard one wrapper is named differently (it's used by stb_truetype)
213 static inline float ImCeil(float x) { return ceilf(x); }
214 #endif
215 // - ImMin/ImMax/ImClamp/ImLerp/ImSwap are used by widgets which support for variety of types: signed/unsigned int/long long float/double, using templates here but we could also redefine them 6 times
216 template<typename T> static inline T ImMin(T lhs, T rhs) { return lhs < rhs ? lhs : rhs; }
217 template<typename T> static inline T ImMax(T lhs, T rhs) { return lhs >= rhs ? lhs : rhs; }
218 template<typename T> static inline T ImClamp(T v, T mn, T mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
219 template<typename T> static inline T ImLerp(T a, T b, float t) { return (T)(a + (b - a) * t); }
220 template<typename T> static inline void ImSwap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
221 // - Misc maths helpers
222 static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }
223 static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }
224 static inline ImVec2 ImClamp(const ImVec2& v, const ImVec2& mn, ImVec2 mx) { return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }
225 static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
226 static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t) { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
227 static inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t) { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
228 static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
229 static inline float ImLengthSqr(const ImVec2& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y; }
230 static inline float ImLengthSqr(const ImVec4& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y + lhs.z*lhs.z + lhs.w*lhs.w; }
231 static inline float ImInvLength(const ImVec2& lhs, float fail_value) { float d = lhs.x*lhs.x + lhs.y*lhs.y; if (d > 0.0f) return 1.0f / ImSqrt(d); return fail_value; }
232 static inline float ImFloor(float f) { return (float)(int)f; }
233 static inline ImVec2 ImFloor(const ImVec2& v) { return ImVec2((float)(int)v.x, (float)(int)v.y); }
234 static inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; }
235 static inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a) { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
236 static inline float ImLinearSweep(float current, float target, float speed) { if (current < target) return ImMin(current + speed, target); if (current > target) return ImMax(current - speed, target); return current; }
237 static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
238 
239 // 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,
240 // Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object.
241 typedef int ImPoolIdx;
242 template<typename T>
243 struct IMGUI_API ImPool
244 {
245  ImVector<T> Data; // Contiguous data
246  ImGuiStorage Map; // ID->Index
247  ImPoolIdx FreeIdx; // Next free idx to use
248 
249  ImPool() { FreeIdx = 0; }
250  ~ImPool() { Clear(); }
251  T* GetByKey(ImGuiID key) { int idx = Map.GetInt(key, -1); return (idx != -1) ? &Data[idx] : NULL; }
252  T* GetByIndex(ImPoolIdx n) { return &Data[n]; }
253  ImPoolIdx GetIndex(const T* p) const { IM_ASSERT(p >= Data.Data && p < Data.Data + Data.Size); return (ImPoolIdx)(p - Data.Data); }
254  T* GetOrAddByKey(ImGuiID key) { int* p_idx = Map.GetIntRef(key, -1); if (*p_idx != -1) return &Data[*p_idx]; *p_idx = FreeIdx; return Add(); }
255  void Clear() { for (int n = 0; n < Map.Data.Size; n++) { int idx = Map.Data[n].val_i; if (idx != -1) Data[idx].~T(); } Map.Clear(); Data.clear(); FreeIdx = 0; }
256  T* Add() { int idx = FreeIdx; if (idx == Data.Size) { Data.resize(Data.Size + 1); FreeIdx++; } else { FreeIdx = *(int*)&Data[idx]; } IM_PLACEMENT_NEW(&Data[idx]) T(); return &Data[idx]; }
257  void Remove(ImGuiID key, const T* p) { Remove(key, GetIndex(p)); }
258  void Remove(ImGuiID key, ImPoolIdx idx) { Data[idx].~T(); *(int*)&Data[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, -1); }
259  void Reserve(int capacity) { Data.reserve(capacity); Map.Data.reserve(capacity); }
260  int GetSize() const { return Data.Size; }
261 };
262 
263 //-----------------------------------------------------------------------------
264 // Misc data structures
265 //-----------------------------------------------------------------------------
266 
267 // 1D vector (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches)
268 struct ImVec1
269 {
270  float x;
271  ImVec1() { x = 0.0f; }
272  ImVec1(float _x) { x = _x; }
273 };
274 
275 enum ImGuiButtonFlags_
276 {
277  ImGuiButtonFlags_None = 0,
278  ImGuiButtonFlags_Repeat = 1 << 0, // hold to repeat
279  ImGuiButtonFlags_PressedOnClickRelease = 1 << 1, // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
280  ImGuiButtonFlags_PressedOnClick = 1 << 2, // return true on click (default requires click+release)
281  ImGuiButtonFlags_PressedOnRelease = 1 << 3, // return true on release (default requires click+release)
282  ImGuiButtonFlags_PressedOnDoubleClick = 1 << 4, // return true on double-click (default requires click+release)
283  ImGuiButtonFlags_FlattenChildren = 1 << 5, // allow interactions even if a child window is overlapping
284  ImGuiButtonFlags_AllowItemOverlap = 1 << 6, // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
285  ImGuiButtonFlags_DontClosePopups = 1 << 7, // disable automatically closing parent popup on press // [UNUSED]
286  ImGuiButtonFlags_Disabled = 1 << 8, // disable interactions
287  ImGuiButtonFlags_AlignTextBaseLine = 1 << 9, // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
288  ImGuiButtonFlags_NoKeyModifiers = 1 << 10, // disable interaction if a key modifier is held
289  ImGuiButtonFlags_NoHoldingActiveID = 1 << 11, // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
290  ImGuiButtonFlags_PressedOnDragDropHold = 1 << 12, // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
291  ImGuiButtonFlags_NoNavFocus = 1 << 13 // don't override navigation focus when activated
292 };
293 
294 enum ImGuiSliderFlags_
295 {
296  ImGuiSliderFlags_None = 0,
297  ImGuiSliderFlags_Vertical = 1 << 0
298 };
299 
300 enum ImGuiDragFlags_
301 {
302  ImGuiDragFlags_None = 0,
303  ImGuiDragFlags_Vertical = 1 << 0
304 };
305 
306 enum ImGuiColumnsFlags_
307 {
308  // Default: 0
309  ImGuiColumnsFlags_None = 0,
310  ImGuiColumnsFlags_NoBorder = 1 << 0, // Disable column dividers
311  ImGuiColumnsFlags_NoResize = 1 << 1, // Disable resizing columns when clicking on the dividers
312  ImGuiColumnsFlags_NoPreserveWidths = 1 << 2, // Disable column width preservation when adjusting columns
313  ImGuiColumnsFlags_NoForceWithinWindow = 1 << 3, // Disable forcing columns to fit within window
314  ImGuiColumnsFlags_GrowParentContentsSize= 1 << 4 // (WIP) Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
315 };
316 
317 enum ImGuiSelectableFlagsPrivate_
318 {
319  // NB: need to be in sync with last value of ImGuiSelectableFlags_
320  ImGuiSelectableFlags_NoHoldingActiveID = 1 << 10,
321  ImGuiSelectableFlags_PressedOnClick = 1 << 11,
322  ImGuiSelectableFlags_PressedOnRelease = 1 << 12,
323  ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 13
324 };
325 
326 enum ImGuiSeparatorFlags_
327 {
328  ImGuiSeparatorFlags_None = 0,
329  ImGuiSeparatorFlags_Horizontal = 1 << 0, // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
330  ImGuiSeparatorFlags_Vertical = 1 << 1
331 };
332 
333 // Storage for LastItem data
334 enum ImGuiItemStatusFlags_
335 {
336  ImGuiItemStatusFlags_None = 0,
337  ImGuiItemStatusFlags_HoveredRect = 1 << 0,
338  ImGuiItemStatusFlags_HasDisplayRect = 1 << 1,
339  ImGuiItemStatusFlags_Edited = 1 << 2 // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
340 
341 #ifdef IMGUI_ENABLE_TEST_ENGINE
342  , // [imgui-test only]
343  ImGuiItemStatusFlags_Openable = 1 << 10, //
344  ImGuiItemStatusFlags_Opened = 1 << 11, //
345  ImGuiItemStatusFlags_Checkable = 1 << 12, //
346  ImGuiItemStatusFlags_Checked = 1 << 13 //
347 #endif
348 };
349 
350 // FIXME: this is in development, not exposed/functional as a generic feature yet.
351 enum ImGuiLayoutType_
352 {
353  ImGuiLayoutType_Vertical = 0,
354  ImGuiLayoutType_Horizontal = 1
355 };
356 
357 enum ImGuiAxis
358 {
359  ImGuiAxis_None = -1,
360  ImGuiAxis_X = 0,
361  ImGuiAxis_Y = 1
362 };
363 
364 enum ImGuiPlotType
365 {
366  ImGuiPlotType_Lines,
367  ImGuiPlotType_Histogram
368 };
369 
370 enum ImGuiInputSource
371 {
372  ImGuiInputSource_None = 0,
373  ImGuiInputSource_Mouse,
374  ImGuiInputSource_Nav,
375  ImGuiInputSource_NavKeyboard, // Only used occasionally for storage, not tested/handled by most code
376  ImGuiInputSource_NavGamepad, // "
377  ImGuiInputSource_COUNT
378 };
379 
380 // FIXME-NAV: Clarify/expose various repeat delay/rate
381 enum ImGuiInputReadMode
382 {
383  ImGuiInputReadMode_Down,
384  ImGuiInputReadMode_Pressed,
385  ImGuiInputReadMode_Released,
386  ImGuiInputReadMode_Repeat,
387  ImGuiInputReadMode_RepeatSlow,
388  ImGuiInputReadMode_RepeatFast
389 };
390 
391 enum ImGuiNavHighlightFlags_
392 {
393  ImGuiNavHighlightFlags_None = 0,
394  ImGuiNavHighlightFlags_TypeDefault = 1 << 0,
395  ImGuiNavHighlightFlags_TypeThin = 1 << 1,
396  ImGuiNavHighlightFlags_AlwaysDraw = 1 << 2,
397  ImGuiNavHighlightFlags_NoRounding = 1 << 3
398 };
399 
400 enum ImGuiNavDirSourceFlags_
401 {
402  ImGuiNavDirSourceFlags_None = 0,
403  ImGuiNavDirSourceFlags_Keyboard = 1 << 0,
404  ImGuiNavDirSourceFlags_PadDPad = 1 << 1,
405  ImGuiNavDirSourceFlags_PadLStick = 1 << 2
406 };
407 
408 enum ImGuiNavMoveFlags_
409 {
410  ImGuiNavMoveFlags_None = 0,
411  ImGuiNavMoveFlags_LoopX = 1 << 0, // On failed request, restart from opposite side
412  ImGuiNavMoveFlags_LoopY = 1 << 1,
413  ImGuiNavMoveFlags_WrapX = 1 << 2, // On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)
414  ImGuiNavMoveFlags_WrapY = 1 << 3, // This is not super useful for provided for completeness
415  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)
416  ImGuiNavMoveFlags_AlsoScoreVisibleSet = 1 << 5 // Store alternate result in NavMoveResultLocalVisibleSet that only comprise elements that are already fully visible.
417 };
418 
419 enum ImGuiNavForward
420 {
421  ImGuiNavForward_None,
422  ImGuiNavForward_ForwardQueued,
423  ImGuiNavForward_ForwardActive
424 };
425 
426 enum ImGuiNavLayer
427 {
428  ImGuiNavLayer_Main = 0, // Main scrolling layer
429  ImGuiNavLayer_Menu = 1, // Menu layer (access with Alt/ImGuiNavInput_Menu)
430  ImGuiNavLayer_COUNT
431 };
432 
433 enum ImGuiPopupPositionPolicy
434 {
435  ImGuiPopupPositionPolicy_Default,
436  ImGuiPopupPositionPolicy_ComboBox
437 };
438 
439 // 2D axis aligned bounding-box
440 // NB: we can't rely on ImVec2 math operators being available here
441 struct IMGUI_API ImRect
442 {
443  ImVec2 Min; // Upper-left
444  ImVec2 Max; // Lower-right
445 
446  ImRect() : Min(FLT_MAX,FLT_MAX), Max(-FLT_MAX,-FLT_MAX) {}
447  ImRect(const ImVec2& min, const ImVec2& max) : Min(min), Max(max) {}
448  ImRect(const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {}
449  ImRect(float x1, float y1, float x2, float y2) : Min(x1, y1), Max(x2, y2) {}
450 
451  ImVec2 GetCenter() const { return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
452  ImVec2 GetSize() const { return ImVec2(Max.x - Min.x, Max.y - Min.y); }
453  float GetWidth() const { return Max.x - Min.x; }
454  float GetHeight() const { return Max.y - Min.y; }
455  ImVec2 GetTL() const { return Min; } // Top-left
456  ImVec2 GetTR() const { return ImVec2(Max.x, Min.y); } // Top-right
457  ImVec2 GetBL() const { return ImVec2(Min.x, Max.y); } // Bottom-left
458  ImVec2 GetBR() const { return Max; } // Bottom-right
459  bool Contains(const ImVec2& p) const { return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; }
460  bool Contains(const ImRect& r) const { return r.Min.x >= Min.x && r.Min.y >= Min.y && r.Max.x <= Max.x && r.Max.y <= Max.y; }
461  bool Overlaps(const ImRect& r) const { return r.Min.y < Max.y && r.Max.y > Min.y && r.Min.x < Max.x && r.Max.x > Min.x; }
462  void Add(const ImVec2& p) { if (Min.x > p.x) Min.x = p.x; if (Min.y > p.y) Min.y = p.y; if (Max.x < p.x) Max.x = p.x; if (Max.y < p.y) Max.y = p.y; }
463  void Add(const ImRect& r) { if (Min.x > r.Min.x) Min.x = r.Min.x; if (Min.y > r.Min.y) Min.y = r.Min.y; if (Max.x < r.Max.x) Max.x = r.Max.x; if (Max.y < r.Max.y) Max.y = r.Max.y; }
464  void Expand(const float amount) { Min.x -= amount; Min.y -= amount; Max.x += amount; Max.y += amount; }
465  void Expand(const ImVec2& amount) { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
466  void Translate(const ImVec2& d) { Min.x += d.x; Min.y += d.y; Max.x += d.x; Max.y += d.y; }
467  void TranslateX(float dx) { Min.x += dx; Max.x += dx; }
468  void TranslateY(float dy) { Min.y += dy; Max.y += dy; }
469  void ClipWith(const ImRect& r) { Min = ImMax(Min, r.Min); Max = ImMin(Max, r.Max); } // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.
470  void ClipWithFull(const ImRect& r) { Min = ImClamp(Min, r.Min, r.Max); Max = ImClamp(Max, r.Min, r.Max); } // Full version, ensure both points are fully clipped.
471  void Floor() { Min.x = (float)(int)Min.x; Min.y = (float)(int)Min.y; Max.x = (float)(int)Max.x; Max.y = (float)(int)Max.y; }
472  bool IsInverted() const { return Min.x > Max.x || Min.y > Max.y; }
473 };
474 
475 // Stacked color modifier, backup of modified data so we can restore it
476 struct ImGuiColorMod
477 {
478  ImGuiCol Col;
479  ImVec4 BackupValue;
480 };
481 
482 // Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
483 struct ImGuiStyleMod
484 {
485  ImGuiStyleVar VarIdx;
486  union { int BackupInt[2]; float BackupFloat[2]; };
487  ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; }
488  ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; }
489  ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }
490 };
491 
492 // Stacked storage data for BeginGroup()/EndGroup()
493 struct ImGuiGroupData
494 {
495  ImVec2 BackupCursorPos;
496  ImVec2 BackupCursorMaxPos;
497  ImVec1 BackupIndent;
498  ImVec1 BackupGroupOffset;
499  ImVec2 BackupCurrentLineSize;
500  float BackupCurrentLineTextBaseOffset;
501  float BackupLogLinePosY;
502  ImGuiID BackupActiveIdIsAlive;
503  bool BackupActiveIdPreviousFrameIsAlive;
504  bool AdvanceCursor;
505 };
506 
507 // Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper.
508 struct IMGUI_API ImGuiMenuColumns
509 {
510  int Count;
511  float Spacing;
512  float Width, NextWidth;
513  float Pos[4], NextWidths[4];
514 
515  ImGuiMenuColumns();
516  void Update(int count, float spacing, bool clear);
517  float DeclColumns(float w0, float w1, float w2);
518  float CalcExtraSpace(float avail_w);
519 };
520 
521 // Internal state of the currently focused/edited text input box
522 struct IMGUI_API ImGuiInputTextState
523 {
524  ImGuiID ID; // widget id owning the text state
525  ImVector<ImWchar> TextW; // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
526  ImVector<char> InitialText; // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
527  ImVector<char> TempBuffer; // temporary buffer for callback and other other operations. size=capacity.
528  int CurLenA, CurLenW; // we need to maintain our buffer length in both UTF-8 and wchar format.
529  int BufCapacityA; // end-user buffer capacity
530  float ScrollX;
531  ImGuiStb::STB_TexteditState StbState;
532  float CursorAnim;
533  bool CursorFollow;
534  bool SelectedAllMouseLock;
535 
536  // Temporarily set when active
537  ImGuiInputTextFlags UserFlags;
538  ImGuiInputTextCallback UserCallback;
539  void* UserCallbackData;
540 
541  ImGuiInputTextState() { memset(this, 0, sizeof(*this)); }
542  void CursorAnimReset() { CursorAnim = -0.30f; } // After a user-input the cursor stays on for a while without blinking
543  void CursorClamp() { StbState.cursor = ImMin(StbState.cursor, CurLenW); StbState.select_start = ImMin(StbState.select_start, CurLenW); StbState.select_end = ImMin(StbState.select_end, CurLenW); }
544  bool HasSelection() const { return StbState.select_start != StbState.select_end; }
545  void ClearSelection() { StbState.select_start = StbState.select_end = StbState.cursor; }
546  void SelectAll() { StbState.select_start = 0; StbState.cursor = StbState.select_end = CurLenW; StbState.has_preferred_x = false; }
547  void OnKeyPressed(int key); // Cannot be inline because we call in code in stb_textedit.h implementation
548 };
549 
550 // Windows data saved in imgui.ini file
551 struct ImGuiWindowSettings
552 {
553  char* Name;
554  ImGuiID ID;
555  ImVec2 Pos;
556  ImVec2 Size;
557  bool Collapsed;
558 
559  ImGuiWindowSettings() { Name = NULL; ID = 0; Pos = Size = ImVec2(0,0); Collapsed = false; }
560 };
561 
562 struct ImGuiSettingsHandler
563 {
564  const char* TypeName; // Short description stored in .ini file. Disallowed characters: '[' ']'
565  ImGuiID TypeHash; // == ImHash(TypeName, 0, 0)
566  void* (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name); // Read: Called when entering into a new ini entry e.g. "[Window][Name]"
567  void (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line); // Read: Called for every line of text within an ini entry
568  void (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf); // Write: Output every entries into 'out_buf'
569  void* UserData;
570 
571  ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
572 };
573 
574 // Storage for current popup stack
575 struct ImGuiPopupRef
576 {
577  ImGuiID PopupId; // Set on OpenPopup()
578  ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
579  ImGuiWindow* ParentWindow; // Set on OpenPopup()
580  int OpenFrameCount; // Set on OpenPopup()
581  ImGuiID OpenParentId; // Set on OpenPopup(), we need this to differenciate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)
582  ImVec2 OpenPopupPos; // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
583  ImVec2 OpenMousePos; // Set on OpenPopup(), copy of mouse position at the time of opening popup
584 };
585 
586 struct ImGuiColumnData
587 {
588  float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
589  float OffsetNormBeforeResize;
590  ImGuiColumnsFlags Flags; // Not exposed
591  ImRect ClipRect;
592 
593  ImGuiColumnData() { OffsetNorm = OffsetNormBeforeResize = 0.0f; Flags = 0; }
594 };
595 
596 struct ImGuiColumnsSet
597 {
598  ImGuiID ID;
599  ImGuiColumnsFlags Flags;
600  bool IsFirstFrame;
601  bool IsBeingResized;
602  int Current;
603  int Count;
604  float MinX, MaxX;
605  float LineMinY, LineMaxY;
606  float StartPosY; // Copy of CursorPos
607  float StartMaxPosX; // Copy of CursorMaxPos
608  ImVector<ImGuiColumnData> Columns;
609 
610  ImGuiColumnsSet() { Clear(); }
611  void Clear()
612  {
613  ID = 0;
614  Flags = 0;
615  IsFirstFrame = false;
616  IsBeingResized = false;
617  Current = 0;
618  Count = 1;
619  MinX = MaxX = 0.0f;
620  LineMinY = LineMaxY = 0.0f;
621  StartPosY = 0.0f;
622  StartMaxPosX = 0.0f;
623  Columns.clear();
624  }
625 };
626 
627 // Data shared between all ImDrawList instances
628 struct IMGUI_API ImDrawListSharedData
629 {
630  ImVec2 TexUvWhitePixel; // UV of white pixel in the atlas
631  ImFont* Font; // Current/default font (optional, for simplified AddText overload)
632  float FontSize; // Current/default font size (optional, for simplified AddText overload)
633  float CurveTessellationTol;
634  ImVec4 ClipRectFullscreen; // Value for PushClipRectFullscreen()
635 
636  // Const data
637  // FIXME: Bake rounded corners fill/borders in atlas
638  ImVec2 CircleVtx12[12];
639 
640  ImDrawListSharedData();
641 };
642 
643 struct ImDrawDataBuilder
644 {
645  ImVector<ImDrawList*> Layers[2]; // Global layers for: regular, tooltip
646 
647  void Clear() { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].resize(0); }
648  void ClearFreeMemory() { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].clear(); }
649  IMGUI_API void FlattenIntoSingleLayer();
650 };
651 
652 struct ImGuiNavMoveResult
653 {
654  ImGuiID ID; // Best candidate
655  ImGuiWindow* Window; // Best candidate window
656  float DistBox; // Best candidate box distance to current NavId
657  float DistCenter; // Best candidate center distance to current NavId
658  float DistAxial;
659  ImRect RectRel; // Best candidate bounding box in window relative space
660 
661  ImGuiNavMoveResult() { Clear(); }
662  void Clear() { ID = 0; Window = NULL; DistBox = DistCenter = DistAxial = FLT_MAX; RectRel = ImRect(); }
663 };
664 
665 // Storage for SetNexWindow** functions
666 struct ImGuiNextWindowData
667 {
668  ImGuiCond PosCond;
669  ImGuiCond SizeCond;
670  ImGuiCond ContentSizeCond;
671  ImGuiCond CollapsedCond;
672  ImGuiCond SizeConstraintCond;
673  ImGuiCond FocusCond;
674  ImGuiCond BgAlphaCond;
675  ImVec2 PosVal;
676  ImVec2 PosPivotVal;
677  ImVec2 SizeVal;
678  ImVec2 ContentSizeVal;
679  bool CollapsedVal;
680  ImRect SizeConstraintRect;
681  ImGuiSizeCallback SizeCallback;
682  void* SizeCallbackUserData;
683  float BgAlphaVal;
684  ImVec2 MenuBarOffsetMinVal; // This is not exposed publicly, so we don't clear it.
685 
686  ImGuiNextWindowData()
687  {
688  PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = BgAlphaCond = 0;
689  PosVal = PosPivotVal = SizeVal = ImVec2(0.0f, 0.0f);
690  ContentSizeVal = ImVec2(0.0f, 0.0f);
691  CollapsedVal = false;
692  SizeConstraintRect = ImRect();
693  SizeCallback = NULL;
694  SizeCallbackUserData = NULL;
695  BgAlphaVal = FLT_MAX;
696  MenuBarOffsetMinVal = ImVec2(0.0f, 0.0f);
697  }
698 
699  void Clear()
700  {
701  PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = BgAlphaCond = 0;
702  }
703 };
704 
705 struct ImGuiTabBarSortItem
706 {
707  int Index;
708  float Width;
709 };
710 
711 //-----------------------------------------------------------------------------
712 // Main imgui context
713 //-----------------------------------------------------------------------------
714 
715 struct ImGuiContext
716 {
717  bool Initialized;
718  bool FrameScopeActive; // Set by NewFrame(), cleared by EndFrame()
719  bool FrameScopePushedImplicitWindow; // Set by NewFrame(), cleared by EndFrame()
720  bool FontAtlasOwnedByContext; // Io.Fonts-> is owned by the ImGuiContext and will be destructed along with it.
721  ImGuiIO IO;
722  ImGuiStyle Style;
723  ImFont* Font; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
724  float FontSize; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
725  float FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
726  ImDrawListSharedData DrawListSharedData;
727 
728  double Time;
729  int FrameCount;
730  int FrameCountEnded;
731  int FrameCountRendered;
732  ImVector<ImGuiWindow*> Windows; // Windows, sorted in display order, back to front
733  ImVector<ImGuiWindow*> WindowsFocusOrder; // Windows, sorted in focus order, back to front
734  ImVector<ImGuiWindow*> WindowsSortBuffer;
735  ImVector<ImGuiWindow*> CurrentWindowStack;
736  ImGuiStorage WindowsById;
737  int WindowsActiveCount;
738  ImGuiWindow* CurrentWindow; // Being drawn into
739  ImGuiWindow* HoveredWindow; // Will catch mouse inputs
740  ImGuiWindow* HoveredRootWindow; // Will catch mouse inputs (for focus/move only)
741  ImGuiID HoveredId; // Hovered widget
742  bool HoveredIdAllowOverlap;
743  ImGuiID HoveredIdPreviousFrame;
744  float HoveredIdTimer; // Measure contiguous hovering time
745  float HoveredIdNotActiveTimer; // Measure contiguous hovering time where the item has not been active
746  ImGuiID ActiveId; // Active widget
747  ImGuiID ActiveIdPreviousFrame;
748  ImGuiID ActiveIdIsAlive; // Active widget has been seen this frame (we can't use a bool as the ActiveId may change within the frame)
749  float ActiveIdTimer;
750  bool ActiveIdIsJustActivated; // Set at the time of activation for one frame
751  bool ActiveIdAllowOverlap; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
752  bool ActiveIdHasBeenEdited; // Was the value associated to the widget Edited over the course of the Active state.
753  bool ActiveIdPreviousFrameIsAlive;
754  bool ActiveIdPreviousFrameHasBeenEdited;
755  int ActiveIdAllowNavDirFlags; // Active widget allows using directional navigation (e.g. can activate a button and move away from it)
756  ImVec2 ActiveIdClickOffset; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
757  ImGuiWindow* ActiveIdWindow;
758  ImGuiWindow* ActiveIdPreviousFrameWindow;
759  ImGuiInputSource ActiveIdSource; // Activating with mouse or nav (gamepad/keyboard)
760  ImGuiID LastActiveId; // Store the last non-zero ActiveId, useful for animation.
761  float LastActiveIdTimer; // Store the last non-zero ActiveId timer since the beginning of activation, useful for animation.
762  ImVec2 LastValidMousePos;
763  ImGuiWindow* MovingWindow; // Track the window we clicked on (in order to preserve focus). The actually window that is moved is generally MovingWindow->RootWindow.
764  ImVector<ImGuiColorMod> ColorModifiers; // Stack for PushStyleColor()/PopStyleColor()
765  ImVector<ImGuiStyleMod> StyleModifiers; // Stack for PushStyleVar()/PopStyleVar()
766  ImVector<ImFont*> FontStack; // Stack for PushFont()/PopFont()
767  ImVector<ImGuiPopupRef> OpenPopupStack; // Which popups are open (persistent)
768  ImVector<ImGuiPopupRef> BeginPopupStack; // Which level of BeginPopup() we are in (reset every frame)
769  ImGuiNextWindowData NextWindowData; // Storage for SetNextWindow** functions
770  bool NextTreeNodeOpenVal; // Storage for SetNextTreeNode** functions
771  ImGuiCond NextTreeNodeOpenCond;
772 
773  // Navigation data (for gamepad/keyboard)
774  ImGuiWindow* NavWindow; // Focused window for navigation. Could be called 'FocusWindow'
775  ImGuiID NavId; // Focused item for navigation
776  ImGuiID NavActivateId; // ~~ (g.ActiveId == 0) && IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0, also set when calling ActivateItem()
777  ImGuiID NavActivateDownId; // ~~ IsNavInputDown(ImGuiNavInput_Activate) ? NavId : 0
778  ImGuiID NavActivatePressedId; // ~~ IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0
779  ImGuiID NavInputId; // ~~ IsNavInputPressed(ImGuiNavInput_Input) ? NavId : 0
780  ImGuiID NavJustTabbedId; // Just tabbed to this id.
781  ImGuiID NavJustMovedToId; // Just navigated to this id (result of a successfully MoveRequest)
782  ImGuiID NavNextActivateId; // Set by ActivateItem(), queued until next frame
783  ImGuiInputSource NavInputSource; // Keyboard or Gamepad mode? THIS WILL ONLY BE None or NavGamepad or NavKeyboard.
784  ImRect NavScoringRectScreen; // Rectangle used for scoring, in screen space. Based of window->DC.NavRefRectRel[], modified for directional navigation scoring.
785  int NavScoringCount; // Metrics for debugging
786  ImGuiWindow* NavWindowingTarget; // When selecting a window (holding Menu+FocusPrev/Next, or equivalent of CTRL-TAB) this window is temporarily displayed front-most.
787  ImGuiWindow* NavWindowingTargetAnim; // Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f
788  ImGuiWindow* NavWindowingList;
789  float NavWindowingTimer;
790  float NavWindowingHighlightAlpha;
791  bool NavWindowingToggleLayer;
792  ImGuiNavLayer NavLayer; // Layer we are navigating on. For now the system is hard-coded for 0=main contents and 1=menu/title bar, may expose layers later.
793  int NavIdTabCounter; // == NavWindow->DC.FocusIdxTabCounter at time of NavId processing
794  bool NavIdIsAlive; // Nav widget has been seen this frame ~~ NavRefRectRel is valid
795  bool NavMousePosDirty; // When set we will update mouse position if (io.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos) if set (NB: this not enabled by default)
796  bool NavDisableHighlight; // When user starts using mouse, we hide gamepad/keyboard highlight (NB: but they are still available, which is why NavDisableHighlight isn't always != NavDisableMouseHover)
797  bool NavDisableMouseHover; // When user starts using gamepad/keyboard, we hide mouse hovering highlight until mouse is touched again.
798  bool NavAnyRequest; // ~~ NavMoveRequest || NavInitRequest
799  bool NavInitRequest; // Init request for appearing window to select first item
800  bool NavInitRequestFromMove;
801  ImGuiID NavInitResultId;
802  ImRect NavInitResultRectRel;
803  bool NavMoveFromClampedRefRect; // Set by manual scrolling, if we scroll to a point where NavId isn't visible we reset navigation from visible items
804  bool NavMoveRequest; // Move request for this frame
805  ImGuiNavMoveFlags NavMoveRequestFlags;
806  ImGuiNavForward NavMoveRequestForward; // None / ForwardQueued / ForwardActive (this is used to navigate sibling parent menus from a child menu)
807  ImGuiDir NavMoveDir, NavMoveDirLast; // Direction of the move request (left/right/up/down), direction of the previous move request
808  ImGuiDir NavMoveClipDir;
809  ImGuiNavMoveResult NavMoveResultLocal; // Best move request candidate within NavWindow
810  ImGuiNavMoveResult NavMoveResultLocalVisibleSet; // Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag)
811  ImGuiNavMoveResult NavMoveResultOther; // Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag)
812 
813  // Render
814  ImDrawData DrawData; // Main ImDrawData instance to pass render information to the user
815  ImDrawDataBuilder DrawDataBuilder;
816  float DimBgRatio; // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)
817  ImDrawList OverlayDrawList; // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays
818  ImGuiMouseCursor MouseCursor;
819 
820  // Drag and Drop
821  bool DragDropActive;
822  bool DragDropWithinSourceOrTarget;
823  ImGuiDragDropFlags DragDropSourceFlags;
824  int DragDropSourceFrameCount;
825  int DragDropMouseButton;
826  ImGuiPayload DragDropPayload;
827  ImRect DragDropTargetRect;
828  ImGuiID DragDropTargetId;
829  ImGuiDragDropFlags DragDropAcceptFlags;
830  float DragDropAcceptIdCurrRectSurface; // Target item surface (we resolve overlapping targets by prioritizing the smaller surface)
831  ImGuiID DragDropAcceptIdCurr; // Target item id (set at the time of accepting the payload)
832  ImGuiID DragDropAcceptIdPrev; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
833  int DragDropAcceptFrameCount; // Last time a target expressed a desire to accept the source
834  ImVector<unsigned char> DragDropPayloadBufHeap; // We don't expose the ImVector<> directly
835  unsigned char DragDropPayloadBufLocal[8]; // Local buffer for small payloads
836 
837  // Tab bars
838  ImPool<ImGuiTabBar> TabBars;
839  ImVector<ImGuiTabBar*> CurrentTabBar;
840  ImVector<ImGuiTabBarSortItem> TabSortByWidthBuffer;
841 
842  // Widget state
843  ImGuiInputTextState InputTextState;
844  ImFont InputTextPasswordFont;
845  ImGuiID ScalarAsInputTextId; // Temporary text input when CTRL+clicking on a slider, etc.
846  ImGuiColorEditFlags ColorEditOptions; // Store user options for color edit widgets
847  ImVec4 ColorPickerRef;
848  bool DragCurrentAccumDirty;
849  float DragCurrentAccum; // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings
850  float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
851  ImVec2 ScrollbarClickDeltaToGrabCenter; // Distance between mouse and center of grab box, normalized in parent space. Use storage?
852  int TooltipOverrideCount;
853  ImVector<char> PrivateClipboard; // If no custom clipboard handler is defined
854 
855  // Platform support
856  ImVec2 PlatformImePos, PlatformImeLastPos; // Cursor position request & last passed to the OS Input Method Editor
857 
858  // Settings
859  bool SettingsLoaded;
860  float SettingsDirtyTimer; // Save .ini Settings to memory when time reaches zero
861  ImGuiTextBuffer SettingsIniData; // In memory .ini settings
862  ImVector<ImGuiSettingsHandler> SettingsHandlers; // List of .ini settings handlers
863  ImVector<ImGuiWindowSettings> SettingsWindows; // ImGuiWindow .ini settings entries (parsed from the last loaded .ini file and maintained on saving)
864 
865  // Logging
866  bool LogEnabled;
867  FILE* LogFile; // If != NULL log to stdout/ file
868  ImGuiTextBuffer LogClipboard; // Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
869  int LogStartDepth;
870  int LogAutoExpandMaxDepth;
871 
872  // Misc
873  float FramerateSecPerFrame[120]; // Calculate estimate of framerate for user over the last 2 seconds.
874  int FramerateSecPerFrameIdx;
875  float FramerateSecPerFrameAccum;
876  int WantCaptureMouseNextFrame; // Explicit capture via CaptureKeyboardFromApp()/CaptureMouseFromApp() sets those flags
877  int WantCaptureKeyboardNextFrame;
878  int WantTextInputNextFrame;
879  char TempBuffer[1024*3+1]; // Temporary text buffer
880 
881  ImGuiContext(ImFontAtlas* shared_font_atlas) : OverlayDrawList(NULL)
882  {
883  Initialized = false;
884  FrameScopeActive = FrameScopePushedImplicitWindow = false;
885  Font = NULL;
886  FontSize = FontBaseSize = 0.0f;
887  FontAtlasOwnedByContext = shared_font_atlas ? false : true;
888  IO.Fonts = shared_font_atlas ? shared_font_atlas : IM_NEW(ImFontAtlas)();
889 
890  Time = 0.0f;
891  FrameCount = 0;
892  FrameCountEnded = FrameCountRendered = -1;
893  WindowsActiveCount = 0;
894  CurrentWindow = NULL;
895  HoveredWindow = NULL;
896  HoveredRootWindow = NULL;
897  HoveredId = 0;
898  HoveredIdAllowOverlap = false;
899  HoveredIdPreviousFrame = 0;
900  HoveredIdTimer = HoveredIdNotActiveTimer = 0.0f;
901  ActiveId = 0;
902  ActiveIdPreviousFrame = 0;
903  ActiveIdIsAlive = 0;
904  ActiveIdTimer = 0.0f;
905  ActiveIdIsJustActivated = false;
906  ActiveIdAllowOverlap = false;
907  ActiveIdHasBeenEdited = false;
908  ActiveIdPreviousFrameIsAlive = false;
909  ActiveIdPreviousFrameHasBeenEdited = false;
910  ActiveIdAllowNavDirFlags = 0;
911  ActiveIdClickOffset = ImVec2(-1,-1);
912  ActiveIdWindow = ActiveIdPreviousFrameWindow = NULL;
913  ActiveIdSource = ImGuiInputSource_None;
914  LastActiveId = 0;
915  LastActiveIdTimer = 0.0f;
916  LastValidMousePos = ImVec2(0.0f, 0.0f);
917  MovingWindow = NULL;
918  NextTreeNodeOpenVal = false;
919  NextTreeNodeOpenCond = 0;
920 
921  NavWindow = NULL;
922  NavId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavInputId = 0;
923  NavJustTabbedId = NavJustMovedToId = NavNextActivateId = 0;
924  NavInputSource = ImGuiInputSource_None;
925  NavScoringRectScreen = ImRect();
926  NavScoringCount = 0;
927  NavWindowingTarget = NavWindowingTargetAnim = NavWindowingList = NULL;
928  NavWindowingTimer = NavWindowingHighlightAlpha = 0.0f;
929  NavWindowingToggleLayer = false;
930  NavLayer = ImGuiNavLayer_Main;
931  NavIdTabCounter = INT_MAX;
932  NavIdIsAlive = false;
933  NavMousePosDirty = false;
934  NavDisableHighlight = true;
935  NavDisableMouseHover = false;
936  NavAnyRequest = false;
937  NavInitRequest = false;
938  NavInitRequestFromMove = false;
939  NavInitResultId = 0;
940  NavMoveFromClampedRefRect = false;
941  NavMoveRequest = false;
942  NavMoveRequestFlags = 0;
943  NavMoveRequestForward = ImGuiNavForward_None;
944  NavMoveDir = NavMoveDirLast = NavMoveClipDir = ImGuiDir_None;
945 
946  DimBgRatio = 0.0f;
947  OverlayDrawList._Data = &DrawListSharedData;
948  OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging
949  MouseCursor = ImGuiMouseCursor_Arrow;
950 
951  DragDropActive = DragDropWithinSourceOrTarget = false;
952  DragDropSourceFlags = 0;
953  DragDropSourceFrameCount = -1;
954  DragDropMouseButton = -1;
955  DragDropTargetId = 0;
956  DragDropAcceptFlags = 0;
957  DragDropAcceptIdCurrRectSurface = 0.0f;
958  DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
959  DragDropAcceptFrameCount = -1;
960  memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal));
961 
962  ScalarAsInputTextId = 0;
963  ColorEditOptions = ImGuiColorEditFlags__OptionsDefault;
964  DragCurrentAccumDirty = false;
965  DragCurrentAccum = 0.0f;
966  DragSpeedDefaultRatio = 1.0f / 100.0f;
967  ScrollbarClickDeltaToGrabCenter = ImVec2(0.0f, 0.0f);
968  TooltipOverrideCount = 0;
969  PlatformImePos = PlatformImeLastPos = ImVec2(FLT_MAX, FLT_MAX);
970 
971  SettingsLoaded = false;
972  SettingsDirtyTimer = 0.0f;
973 
974  LogEnabled = false;
975  LogFile = NULL;
976  LogStartDepth = 0;
977  LogAutoExpandMaxDepth = 2;
978 
979  memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
980  FramerateSecPerFrameIdx = 0;
981  FramerateSecPerFrameAccum = 0.0f;
982  WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
983  memset(TempBuffer, 0, sizeof(TempBuffer));
984  }
985 };
986 
987 // Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
988 // This is going to be exposed in imgui.h when stabilized enough.
989 enum ImGuiItemFlags_
990 {
991  ImGuiItemFlags_NoTabStop = 1 << 0, // false
992  ImGuiItemFlags_ButtonRepeat = 1 << 1, // false // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
993  ImGuiItemFlags_Disabled = 1 << 2, // false // [BETA] Disable interactions but doesn't affect visuals yet. See github.com/ocornut/imgui/issues/211
994  ImGuiItemFlags_NoNav = 1 << 3, // false
995  ImGuiItemFlags_NoNavDefaultFocus = 1 << 4, // false
996  ImGuiItemFlags_SelectableDontClosePopup = 1 << 5, // false // MenuItem/Selectable() automatically closes current Popup window
997  ImGuiItemFlags_Default_ = 0
998 };
999 
1000 // Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow.
1001 // FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered.
1002 struct IMGUI_API ImGuiWindowTempData
1003 {
1004  ImVec2 CursorPos;
1005  ImVec2 CursorPosPrevLine;
1006  ImVec2 CursorStartPos; // Initial position in client area with padding
1007  ImVec2 CursorMaxPos; // Used to implicitly calculate the size of our contents, always growing during the frame. Turned into window->SizeContents at the beginning of next frame
1008  ImVec2 CurrentLineSize;
1009  float CurrentLineTextBaseOffset;
1010  ImVec2 PrevLineSize;
1011  float PrevLineTextBaseOffset;
1012  float LogLinePosY;
1013  int TreeDepth;
1014  ImU32 TreeDepthMayJumpToParentOnPop; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31
1015  ImGuiID LastItemId;
1016  ImGuiItemStatusFlags LastItemStatusFlags;
1017  ImRect LastItemRect; // Interaction rect
1018  ImRect LastItemDisplayRect; // End-user display rect (only valid if LastItemStatusFlags & ImGuiItemStatusFlags_HasDisplayRect)
1019  ImGuiNavLayer NavLayerCurrent; // Current layer, 0..31 (we currently only use 0..1)
1020  int NavLayerCurrentMask; // = (1 << NavLayerCurrent) used by ItemAdd prior to clipping.
1021  int NavLayerActiveMask; // Which layer have been written to (result from previous frame)
1022  int NavLayerActiveMaskNext; // Which layer have been written to (buffer for current frame)
1023  bool NavHideHighlightOneFrame;
1024  bool NavHasScroll; // Set when scrolling can be used (ScrollMax > 0.0f)
1025  bool MenuBarAppending; // FIXME: Remove this
1026  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.
1027  ImVector<ImGuiWindow*> ChildWindows;
1028  ImGuiStorage* StateStorage;
1029  ImGuiLayoutType LayoutType;
1030  ImGuiLayoutType ParentLayoutType; // Layout type of parent window at the time of Begin()
1031 
1032  // 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.
1033  ImGuiItemFlags ItemFlags; // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default]
1034  float ItemWidth; // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
1035  float TextWrapPos; // == TextWrapPosStack.back() [empty == -1.0f]
1036  ImVector<ImGuiItemFlags>ItemFlagsStack;
1037  ImVector<float> ItemWidthStack;
1038  ImVector<float> TextWrapPosStack;
1039  ImVector<ImGuiGroupData>GroupStack;
1040  short StackSizesBackup[6]; // Store size of various stacks for asserting
1041 
1042  ImVec1 Indent; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
1043  ImVec1 GroupOffset;
1044  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.
1045  ImGuiColumnsSet* ColumnsSet; // Current columns set
1046 
1047  ImGuiWindowTempData()
1048  {
1049  CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f);
1050  CurrentLineSize = PrevLineSize = ImVec2(0.0f, 0.0f);
1051  CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f;
1052  LogLinePosY = -1.0f;
1053  TreeDepth = 0;
1054  TreeDepthMayJumpToParentOnPop = 0x00;
1055  LastItemId = 0;
1056  LastItemStatusFlags = 0;
1057  LastItemRect = LastItemDisplayRect = ImRect();
1058  NavLayerActiveMask = NavLayerActiveMaskNext = 0x00;
1059  NavLayerCurrent = ImGuiNavLayer_Main;
1060  NavLayerCurrentMask = (1 << ImGuiNavLayer_Main);
1061  NavHideHighlightOneFrame = false;
1062  NavHasScroll = false;
1063  MenuBarAppending = false;
1064  MenuBarOffset = ImVec2(0.0f, 0.0f);
1065  StateStorage = NULL;
1066  LayoutType = ParentLayoutType = ImGuiLayoutType_Vertical;
1067  ItemWidth = 0.0f;
1068  ItemFlags = ImGuiItemFlags_Default_;
1069  TextWrapPos = -1.0f;
1070  memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
1071 
1072  Indent = ImVec1(0.0f);
1073  GroupOffset = ImVec1(0.0f);
1074  ColumnsOffset = ImVec1(0.0f);
1075  ColumnsSet = NULL;
1076  }
1077 };
1078 
1079 // Storage for one window
1080 struct IMGUI_API ImGuiWindow
1081 {
1082  char* Name;
1083  ImGuiID ID; // == ImHash(Name)
1084  ImGuiWindowFlags Flags; // See enum ImGuiWindowFlags_
1085  ImVec2 Pos; // Position (always rounded-up to nearest pixel)
1086  ImVec2 Size; // Current size (==SizeFull or collapsed title bar size)
1087  ImVec2 SizeFull; // Size when non collapsed
1088  ImVec2 SizeFullAtLastBegin; // Copy of SizeFull at the end of Begin. This is the reference value we'll use on the next frame to decide if we need scrollbars.
1089  ImVec2 SizeContents; // Size of contents (== extents reach of the drawing cursor) from previous frame. Include decoration, window title, border, menu, etc.
1090  ImVec2 SizeContentsExplicit; // Size of contents explicitly set by the user via SetNextWindowContentSize()
1091  ImVec2 WindowPadding; // Window padding at the time of begin.
1092  float WindowRounding; // Window rounding at the time of begin.
1093  float WindowBorderSize; // Window border size at the time of begin.
1094  int NameBufLen; // Size of buffer storing Name. May be larger than strlen(Name)!
1095  ImGuiID MoveId; // == window->GetID("#MOVE")
1096  ImGuiID ChildId; // ID of corresponding item in parent window (for navigation to return from child window to parent window)
1097  ImVec2 Scroll;
1098  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)
1099  ImVec2 ScrollTargetCenterRatio; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
1100  ImVec2 ScrollbarSizes; // Size taken by scrollbars on each axis
1101  bool ScrollbarX, ScrollbarY;
1102  bool Active; // Set to true on Begin(), unless Collapsed
1103  bool WasActive;
1104  bool WriteAccessed; // Set to true when any widget access the current window
1105  bool Collapsed; // Set when collapsing window to become only title-bar
1106  bool WantCollapseToggle;
1107  bool SkipItems; // Set when items can safely be all clipped (e.g. window not visible or collapsed)
1108  bool Appearing; // Set during the frame where the window is appearing (or re-appearing)
1109  bool Hidden; // Do not display (== (HiddenFramesForResize > 0) ||
1110  bool HasCloseButton; // Set when the window has a close button (p_open != NULL)
1111  short BeginCount; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
1112  short BeginOrderWithinParent; // Order within immediate parent window, if we are a child window. Otherwise 0.
1113  short BeginOrderWithinContext; // Order within entire imgui context. This is mostly used for debugging submission order related issues.
1114  ImGuiID PopupId; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
1115  int AutoFitFramesX, AutoFitFramesY;
1116  bool AutoFitOnlyGrows;
1117  int AutoFitChildAxises;
1118  ImGuiDir AutoPosLastDirection;
1119  int HiddenFramesRegular; // Hide the window for N frames
1120  int HiddenFramesForResize; // Hide the window for N frames while allowing items to be submitted so we can measure their size
1121  ImGuiCond SetWindowPosAllowFlags; // store acceptable condition flags for SetNextWindowPos() use.
1122  ImGuiCond SetWindowSizeAllowFlags; // store acceptable condition flags for SetNextWindowSize() use.
1123  ImGuiCond SetWindowCollapsedAllowFlags; // store acceptable condition flags for SetNextWindowCollapsed() use.
1124  ImVec2 SetWindowPosVal; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
1125  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.
1126 
1127  ImGuiWindowTempData DC; // Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the "DC" variable name.
1128  ImVector<ImGuiID> IDStack; // ID stack. ID are hashes seeded with the value at the top of the stack
1129  ImRect ClipRect; // Current clipping rectangle. = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2.
1130  ImRect OuterRectClipped; // = WindowRect just after setup in Begin(). == window->Rect() for root window.
1131  ImRect InnerMainRect, InnerClipRect;
1132  ImRect ContentsRegionRect; // FIXME: This is currently confusing/misleading. Maximum visible content position ~~ Pos + (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis
1133  int LastFrameActive; // Last frame number the window was Active.
1134  float ItemWidthDefault;
1135  ImGuiMenuColumns MenuColumns; // Simplified columns storage for menu items
1136  ImGuiStorage StateStorage;
1137  ImVector<ImGuiColumnsSet> ColumnsStorage;
1138  float FontWindowScale; // User scale multiplier per-window
1139  int SettingsIdx; // Index into SettingsWindow[] (indices are always valid as we only grow the array from the back)
1140 
1141  ImDrawList* DrawList; // == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer)
1142  ImDrawList DrawListInst;
1143  ImGuiWindow* ParentWindow; // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
1144  ImGuiWindow* RootWindow; // Point to ourself or first ancestor that is not a child window.
1145  ImGuiWindow* RootWindowForTitleBarHighlight; // Point to ourself or first ancestor which will display TitleBgActive color when this window is active.
1146  ImGuiWindow* RootWindowForNav; // Point to ourself or first ancestor which doesn't have the NavFlattened flag.
1147 
1148  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.)
1149  ImGuiID NavLastIds[ImGuiNavLayer_COUNT]; // Last known NavId for this window, per layer (0/1)
1150  ImRect NavRectRel[ImGuiNavLayer_COUNT]; // Reference rectangle, in window relative space
1151 
1152  // Navigation / Focus
1153  // FIXME-NAV: Merge all this with the new Nav system, at least the request variables should be moved to ImGuiContext
1154  int FocusIdxAllCounter; // Start at -1 and increase as assigned via FocusItemRegister()
1155  int FocusIdxTabCounter; // (same, but only count widgets which you can Tab through)
1156  int FocusIdxAllRequestCurrent; // Item being requested for focus
1157  int FocusIdxTabRequestCurrent; // Tab-able item being requested for focus
1158  int FocusIdxAllRequestNext; // Item being requested for focus, for next update (relies on layout to be stable between the frame pressing TAB and the next frame)
1159  int FocusIdxTabRequestNext; // "
1160 
1161 public:
1162  ImGuiWindow(ImGuiContext* context, const char* name);
1163  ~ImGuiWindow();
1164 
1165  ImGuiID GetID(const char* str, const char* str_end = NULL);
1166  ImGuiID GetID(const void* ptr);
1167  ImGuiID GetIDNoKeepAlive(const char* str, const char* str_end = NULL);
1168  ImGuiID GetIDNoKeepAlive(const void* ptr);
1169  ImGuiID GetIDFromRectangle(const ImRect& r_abs);
1170 
1171  // We don't use g.FontSize because the window may be != g.CurrentWidow.
1172  ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x+Size.x, Pos.y+Size.y); }
1173  float CalcFontSize() const { return GImGui->FontBaseSize * FontWindowScale; }
1174  float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f; }
1175  ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); }
1176  float MenuBarHeight() const { return (Flags & ImGuiWindowFlags_MenuBar) ? DC.MenuBarOffset.y + CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f : 0.0f; }
1177  ImRect MenuBarRect() const { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); }
1178 };
1179 
1180 // Backup and restore just enough data to be able to use IsItemHovered() on item A after another B in the same window has overwritten the data.
1181 struct ImGuiItemHoveredDataBackup
1182 {
1183  ImGuiID LastItemId;
1184  ImGuiItemStatusFlags LastItemStatusFlags;
1185  ImRect LastItemRect;
1186  ImRect LastItemDisplayRect;
1187 
1188  ImGuiItemHoveredDataBackup() { Backup(); }
1189  void Backup() { ImGuiWindow* window = GImGui->CurrentWindow; LastItemId = window->DC.LastItemId; LastItemStatusFlags = window->DC.LastItemStatusFlags; LastItemRect = window->DC.LastItemRect; LastItemDisplayRect = window->DC.LastItemDisplayRect; }
1190  void Restore() const { ImGuiWindow* window = GImGui->CurrentWindow; window->DC.LastItemId = LastItemId; window->DC.LastItemStatusFlags = LastItemStatusFlags; window->DC.LastItemRect = LastItemRect; window->DC.LastItemDisplayRect = LastItemDisplayRect; }
1191 };
1192 
1193 //-----------------------------------------------------------------------------
1194 // Tab bar, tab item
1195 //-----------------------------------------------------------------------------
1196 
1197 enum ImGuiTabBarFlagsPrivate_
1198 {
1199  ImGuiTabBarFlags_DockNode = 1 << 20, // [Docking: Unused in Master Branch] Part of a dock node
1200  ImGuiTabBarFlags_DockNodeIsDockSpace = 1 << 21, // [Docking: Unused in Master Branch] Part of an explicit dockspace node node
1201  ImGuiTabBarFlags_IsFocused = 1 << 22,
1202  ImGuiTabBarFlags_SaveSettings = 1 << 23 // FIXME: Settings are handled by the docking system, this only request the tab bar to mark settings dirty when reordering tabs
1203 };
1204 
1205 // Storage for one active tab item (sizeof() 26~32 bytes)
1206 struct ImGuiTabItem
1207 {
1208  ImGuiID ID;
1209  ImGuiTabItemFlags Flags;
1210  int LastFrameVisible;
1211  int LastFrameSelected; // This allows us to infer an ordered list of the last activated tabs with little maintenance
1212  float Offset; // Position relative to beginning of tab
1213  float Width; // Width currently displayed
1214  float WidthContents; // Width of actual contents, stored during BeginTabItem() call
1215 
1216  ImGuiTabItem() { ID = Flags = 0; LastFrameVisible = LastFrameSelected = -1; Offset = Width = WidthContents = 0.0f; }
1217 };
1218 
1219 // Storage for a tab bar (sizeof() 92~96 bytes)
1220 struct ImGuiTabBar
1221 {
1222  ImVector<ImGuiTabItem> Tabs;
1223  ImGuiID ID; // Zero for tab-bars used by docking
1224  ImGuiID SelectedTabId; // Selected tab
1225  ImGuiID NextSelectedTabId;
1226  ImGuiID VisibleTabId; // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)
1227  int CurrFrameVisible;
1228  int PrevFrameVisible;
1229  ImRect BarRect;
1230  float ContentsHeight;
1231  float OffsetMax; // Distance from BarRect.Min.x, locked during layout
1232  float OffsetNextTab; // Distance from BarRect.Min.x, incremented with each BeginTabItem() call, not used if ImGuiTabBarFlags_Reorderable if set.
1233  float ScrollingAnim;
1234  float ScrollingTarget;
1235  ImGuiTabBarFlags Flags;
1236  ImGuiID ReorderRequestTabId;
1237  int ReorderRequestDir;
1238  bool WantLayout;
1239  bool VisibleTabWasSubmitted;
1240  short LastTabItemIdx; // For BeginTabItem()/EndTabItem()
1241 
1242  ImGuiTabBar();
1243  int GetTabOrder(const ImGuiTabItem* tab) const { return Tabs.index_from_ptr(tab); }
1244 };
1245 
1246 //-----------------------------------------------------------------------------
1247 // Internal API
1248 // No guarantee of forward compatibility here.
1249 //-----------------------------------------------------------------------------
1250 
1251 namespace ImGui
1252 {
1253  // We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
1254  // If this ever crash because g.CurrentWindow is NULL it means that either
1255  // - ImGui::NewFrame() has never been called, which is illegal.
1256  // - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
1257  inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; }
1258  inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }
1259  IMGUI_API ImGuiWindow* FindWindowByID(ImGuiID id);
1260  IMGUI_API ImGuiWindow* FindWindowByName(const char* name);
1261  IMGUI_API void FocusWindow(ImGuiWindow* window);
1262  IMGUI_API void FocusPreviousWindowIgnoringOne(ImGuiWindow* ignore_window);
1263  IMGUI_API void BringWindowToFocusFront(ImGuiWindow* window);
1264  IMGUI_API void BringWindowToDisplayFront(ImGuiWindow* window);
1265  IMGUI_API void BringWindowToDisplayBack(ImGuiWindow* window);
1266  IMGUI_API void UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window);
1267  IMGUI_API ImVec2 CalcWindowExpectedSize(ImGuiWindow* window);
1268  IMGUI_API bool IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent);
1269  IMGUI_API bool IsWindowNavFocusable(ImGuiWindow* window);
1270  IMGUI_API void SetWindowScrollX(ImGuiWindow* window, float new_scroll_x);
1271  IMGUI_API void SetWindowScrollY(ImGuiWindow* window, float new_scroll_y);
1272  IMGUI_API float GetWindowScrollMaxX(ImGuiWindow* window);
1273  IMGUI_API float GetWindowScrollMaxY(ImGuiWindow* window);
1274  IMGUI_API ImRect GetWindowAllowedExtentRect(ImGuiWindow* window);
1275 
1276  IMGUI_API void SetCurrentFont(ImFont* font);
1277  inline ImFont* GetDefaultFont() { ImGuiContext& g = *GImGui; return g.IO.FontDefault ? g.IO.FontDefault : g.IO.Fonts->Fonts[0]; }
1278 
1279  // Init
1280  IMGUI_API void Initialize(ImGuiContext* context);
1281  IMGUI_API void Shutdown(ImGuiContext* context); // Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext().
1282 
1283  // NewFrame
1284  IMGUI_API void UpdateHoveredWindowAndCaptureFlags();
1285  IMGUI_API void StartMouseMovingWindow(ImGuiWindow* window);
1286  IMGUI_API void UpdateMouseMovingWindowNewFrame();
1287  IMGUI_API void UpdateMouseMovingWindowEndFrame();
1288 
1289  // Settings
1290  IMGUI_API void MarkIniSettingsDirty();
1291  IMGUI_API void MarkIniSettingsDirty(ImGuiWindow* window);
1292  IMGUI_API ImGuiWindowSettings* CreateNewWindowSettings(const char* name);
1293  IMGUI_API ImGuiWindowSettings* FindWindowSettings(ImGuiID id);
1294  IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(const char* type_name);
1295 
1296  // Basic Accessors
1297  inline ImGuiID GetItemID() { ImGuiContext& g = *GImGui; return g.CurrentWindow->DC.LastItemId; }
1298  inline ImGuiID GetActiveID() { ImGuiContext& g = *GImGui; return g.ActiveId; }
1299  inline ImGuiID GetFocusID() { ImGuiContext& g = *GImGui; return g.NavId; }
1300  IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow* window);
1301  IMGUI_API void SetFocusID(ImGuiID id, ImGuiWindow* window);
1302  IMGUI_API void ClearActiveID();
1303  IMGUI_API ImGuiID GetHoveredID();
1304  IMGUI_API void SetHoveredID(ImGuiID id);
1305  IMGUI_API void KeepAliveID(ImGuiID id);
1306  IMGUI_API void MarkItemEdited(ImGuiID id);
1307 
1308  // Basic Helpers for widget code
1309  IMGUI_API void ItemSize(const ImVec2& size, float text_offset_y = 0.0f);
1310  IMGUI_API void ItemSize(const ImRect& bb, float text_offset_y = 0.0f);
1311  IMGUI_API bool ItemAdd(const ImRect& bb, ImGuiID id, const ImRect* nav_bb = NULL);
1312  IMGUI_API bool ItemHoverable(const ImRect& bb, ImGuiID id);
1313  IMGUI_API bool IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged);
1314  IMGUI_API bool FocusableItemRegister(ImGuiWindow* window, ImGuiID id, bool tab_stop = true); // Return true if focus is requested
1315  IMGUI_API void FocusableItemUnregister(ImGuiWindow* window);
1316  IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_x, float default_y);
1317  IMGUI_API float CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
1318  IMGUI_API void PushMultiItemsWidths(int components, float width_full = 0.0f);
1319  IMGUI_API void PushItemFlag(ImGuiItemFlags option, bool enabled);
1320  IMGUI_API void PopItemFlag();
1321 
1322  // Popups, Modals, Tooltips
1323  IMGUI_API void OpenPopupEx(ImGuiID id);
1324  IMGUI_API void ClosePopupToLevel(int remaining, bool apply_focus_to_window_under);
1325  IMGUI_API void ClosePopupsOverWindow(ImGuiWindow* ref_window);
1326  IMGUI_API bool IsPopupOpen(ImGuiID id); // Test for id within current popup stack level (currently begin-ed into); this doesn't scan the whole popup stack!
1327  IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags);
1328  IMGUI_API void BeginTooltipEx(ImGuiWindowFlags extra_flags, bool override_previous_tooltip = true);
1329  IMGUI_API ImGuiWindow* GetFrontMostPopupModal();
1330  IMGUI_API ImVec2 FindBestWindowPosForPopup(ImGuiWindow* window);
1331  IMGUI_API ImVec2 FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy = ImGuiPopupPositionPolicy_Default);
1332 
1333  // Navigation
1334  IMGUI_API void NavInitWindow(ImGuiWindow* window, bool force_reinit);
1335  IMGUI_API bool NavMoveRequestButNoResultYet();
1336  IMGUI_API void NavMoveRequestCancel();
1337  IMGUI_API void NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect& bb_rel, ImGuiNavMoveFlags move_flags);
1338  IMGUI_API void NavMoveRequestTryWrapping(ImGuiWindow* window, ImGuiNavMoveFlags move_flags);
1339  IMGUI_API float GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode);
1340  IMGUI_API ImVec2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor = 0.0f, float fast_factor = 0.0f);
1341  IMGUI_API int CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate);
1342  IMGUI_API void ActivateItem(ImGuiID id); // Remotely activate a button, checkbox, tree node etc. given its unique ID. activation is queued and processed on the next frame when the item is encountered again.
1343  IMGUI_API void SetNavID(ImGuiID id, int nav_layer);
1344  IMGUI_API void SetNavIDWithRectRel(ImGuiID id, int nav_layer, const ImRect& rect_rel);
1345 
1346  // Inputs
1347  inline bool IsKeyPressedMap(ImGuiKey key, bool repeat = true) { const int key_index = GImGui->IO.KeyMap[key]; return (key_index >= 0) ? IsKeyPressed(key_index, repeat) : false; }
1348  inline bool IsNavInputDown(ImGuiNavInput n) { return GImGui->IO.NavInputs[n] > 0.0f; }
1349  inline bool IsNavInputPressed(ImGuiNavInput n, ImGuiInputReadMode mode) { return GetNavInputAmount(n, mode) > 0.0f; }
1350  inline bool IsNavInputPressedAnyOfTwo(ImGuiNavInput n1, ImGuiNavInput n2, ImGuiInputReadMode mode) { return (GetNavInputAmount(n1, mode) + GetNavInputAmount(n2, mode)) > 0.0f; }
1351 
1352  // Drag and Drop
1353  IMGUI_API bool BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
1354  IMGUI_API void ClearDragDrop();
1355  IMGUI_API bool IsDragDropPayloadBeingAccepted();
1356 
1357  // New Columns API (FIXME-WIP)
1358  IMGUI_API void BeginColumns(const char* str_id, int count, ImGuiColumnsFlags flags = 0); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
1359  IMGUI_API void EndColumns(); // close columns
1360  IMGUI_API void PushColumnClipRect(int column_index = -1);
1361 
1362  // Tab Bars
1363  IMGUI_API bool BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& bb, ImGuiTabBarFlags flags);
1364  IMGUI_API ImGuiTabItem* TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id);
1365  IMGUI_API void TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id);
1366  IMGUI_API void TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
1367  IMGUI_API void TabBarQueueChangeTabOrder(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, int dir);
1368  IMGUI_API bool TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags);
1369  IMGUI_API ImVec2 TabItemCalcSize(const char* label, bool has_close_button);
1370  IMGUI_API void TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col);
1371  IMGUI_API bool TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, const char* label, ImGuiID tab_id, ImGuiID close_button_id);
1372 
1373  // Render helpers
1374  // 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.
1375  // NB: All position are in absolute pixels coordinates (we are never using window coordinates internally)
1376  IMGUI_API void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
1377  IMGUI_API void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
1378  IMGUI_API void RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0,0), const ImRect* clip_rect = NULL);
1379  IMGUI_API void RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
1380  IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f);
1381  IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f);
1382  IMGUI_API void RenderColorRectWithAlphaCheckerboard(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, int rounding_corners_flags = ~0);
1383  IMGUI_API void RenderArrow(ImVec2 pos, ImGuiDir dir, float scale = 1.0f);
1384  IMGUI_API void RenderBullet(ImVec2 pos);
1385  IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col, float sz);
1386  IMGUI_API void RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags = ImGuiNavHighlightFlags_TypeDefault); // Navigation highlight
1387  IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
1388  IMGUI_API void LogRenderedText(const ImVec2* ref_pos, const char* text, const char* text_end = NULL);
1389 
1390  // Render helpers (those functions don't access any ImGui state!)
1391  IMGUI_API void RenderMouseCursor(ImDrawList* draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor = ImGuiMouseCursor_Arrow);
1392  IMGUI_API void RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col);
1393  IMGUI_API void RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
1394  IMGUI_API void RenderPixelEllipsis(ImDrawList* draw_list, ImVec2 pos, int count, ImU32 col);
1395 
1396  // Widgets
1397  IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0,0), ImGuiButtonFlags flags = 0);
1398  IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos, float radius);
1399  IMGUI_API bool CollapseButton(ImGuiID id, const ImVec2& pos);
1400  IMGUI_API bool ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags);
1401  IMGUI_API void Scrollbar(ImGuiLayoutType direction);
1402  IMGUI_API void VerticalSeparator(); // Vertical separator, for menu bars (use current line height). Not exposed because it is misleading and it doesn't have an effect on regular layout.
1403 
1404  // Widgets low-level behaviors
1405  IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
1406  IMGUI_API bool DragBehavior(ImGuiID id, ImGuiDataType data_type, void* v, float v_speed, const void* v_min, const void* v_max, const char* format, float power, ImGuiDragFlags flags);
1407  IMGUI_API bool SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* v, const void* v_min, const void* v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb);
1408  IMGUI_API bool SplitterBehavior(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f, float hover_visibility_delay = 0.0f);
1409  IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL);
1410  IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0); // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging
1411  IMGUI_API void TreePushRawID(ImGuiID id);
1412 
1413  // Template functions are instantiated in imgui_widgets.cpp for a finite number of types.
1414  // To use them externally (for custom widget) you may need an "extern template" statement in your code in order to link to existing instances and silence Clang warnings (see #2036).
1415  // e.g. " extern template IMGUI_API float RoundScalarWithFormatT<float, float>(const char* format, ImGuiDataType data_type, float v); "
1416  template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool DragBehaviorT(ImGuiDataType data_type, T* v, float v_speed, const T v_min, const T v_max, const char* format, float power, ImGuiDragFlags flags);
1417  template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, T* v, const T v_min, const T v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb);
1418  template<typename T, typename FLOAT_T> IMGUI_API float SliderCalcRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, float power, float linear_zero_pos);
1419  template<typename T, typename SIGNED_T> IMGUI_API T RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, T v);
1420 
1421  // InputText
1422  IMGUI_API bool InputTextEx(const char* label, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
1423  IMGUI_API bool InputScalarAsWidgetReplacement(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* data_ptr, const char* format);
1424 
1425  // Color
1426  IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
1427  IMGUI_API void ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
1428  IMGUI_API void ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags);
1429 
1430  // Plot
1431  IMGUI_API void 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 graph_size);
1432 
1433  // Shade functions (write over already created vertices)
1434  IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
1435  IMGUI_API void ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp);
1436 
1437 } // namespace ImGui
1438 
1439 // ImFontAtlas internals
1440 IMGUI_API bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas);
1441 IMGUI_API void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas* atlas);
1442 IMGUI_API void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent);
1443 IMGUI_API void ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* spc);
1444 IMGUI_API void ImFontAtlasBuildFinish(ImFontAtlas* atlas);
1445 IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor);
1446 IMGUI_API void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride);
1447 
1448 // Test engine hooks (imgui-test)
1449 //#define IMGUI_ENABLE_TEST_ENGINE
1450 #ifdef IMGUI_ENABLE_TEST_ENGINE
1451 extern void ImGuiTestEngineHook_PreNewFrame(ImGuiContext* ctx);
1452 extern void ImGuiTestEngineHook_PostNewFrame(ImGuiContext* ctx);
1453 extern void ImGuiTestEngineHook_ItemAdd(ImGuiContext* ctx, const ImRect& bb, ImGuiID id);
1454 extern void ImGuiTestEngineHook_ItemInfo(ImGuiContext* ctx, ImGuiID id, const char* label, int flags);
1455 #define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS) ImGuiTestEngineHook_ItemInfo(&g, _ID, _LABEL, _FLAGS) // Register status flags
1456 #else
1457 #define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS) do { } while (0)
1458 #endif
1459 
1460 #ifdef __clang__
1461 #pragma clang diagnostic pop
1462 #endif
1463 
1464 #ifdef _MSC_VER
1465 #pragma warning (pop)
1466 #endif
ImGuiGroupData::AdvanceCursor
bool AdvanceCursor
Definition: imgui_internal.h:504
ImGuiIO::KeyMap
int KeyMap[ImGuiKey_COUNT]
Definition: imgui.h:1285
ImGui::InputScalarAsWidgetReplacement
IMGUI_API bool InputScalarAsWidgetReplacement(const ImRect &bb, ImGuiID id, const char *label, ImGuiDataType data_type, void *data_ptr, const char *format)
Definition: imgui_widgets.cpp:2609
ImGuiTabItem::Offset
float Offset
Definition: imgui_internal.h:1212
ImGuiDragFlags_
ImGuiDragFlags_
Definition: imgui_internal.h:300
ImGuiInputTextState::InitialText
ImVector< char > InitialText
Definition: imgui_internal.h:526
ImGuiContext::InputTextState
ImGuiInputTextState InputTextState
Definition: imgui_internal.h:843
ImGuiNextWindowData::PosCond
ImGuiCond PosCond
Definition: imgui_internal.h:668
ImGuiContext::ActiveIdSource
ImGuiInputSource ActiveIdSource
Definition: imgui_internal.h:759
ImGuiAxis_Y
@ ImGuiAxis_Y
Definition: imgui_internal.h:361
ImGui::DragBehaviorT
IMGUI_API bool DragBehaviorT(ImGuiDataType data_type, T *v, float v_speed, const T v_min, const T v_max, const char *format, float power, ImGuiDragFlags flags)
ImSqrt
static float ImSqrt(float x)
Definition: imgui_internal.h:202
ImGui::CalcWindowExpectedSize
IMGUI_API ImVec2 CalcWindowExpectedSize(ImGuiWindow *window)
Definition: imgui.cpp:4512
ImGuiWindow::WasActive
bool WasActive
Definition: imgui_internal.h:1103
ImIsPowerOfTwo
static bool ImIsPowerOfTwo(int v)
Definition: imgui_internal.h:149
ImGuiMenuColumns
Definition: imgui_internal.h:508
ImGuiColumnsSet::MinX
float MinX
Definition: imgui_internal.h:604
ImGuiNextWindowData::ContentSizeCond
ImGuiCond ContentSizeCond
Definition: imgui_internal.h:670
ImGuiColumnsSet::ImGuiColumnsSet
ImGuiColumnsSet()
Definition: imgui_internal.h:610
ImGuiMenuColumns::Width
float Width
Definition: imgui_internal.h:512
ImGuiAxis_None
@ ImGuiAxis_None
Definition: imgui_internal.h:359
ImGuiNavMoveFlags
int ImGuiNavMoveFlags
Definition: imgui_internal.h:84
ImGuiWindow::WindowRounding
float WindowRounding
Definition: imgui_internal.h:1092
ImGui::ColorPickerOptionsPopup
IMGUI_API void ColorPickerOptionsPopup(const float *ref_col, ImGuiColorEditFlags flags)
Definition: imgui_widgets.cpp:4554
ImGuiDragDropFlags
int ImGuiDragDropFlags
Definition: imgui.h:136
ImGuiContext::NavMoveRequest
bool NavMoveRequest
Definition: imgui_internal.h:804
ImRect::Contains
bool Contains(const ImRect &r) const
Definition: imgui_internal.h:460
ImGuiContext::NavInitRequestFromMove
bool NavInitRequestFromMove
Definition: imgui_internal.h:800
ImGuiNavMoveResult::RectRel
ImRect RectRel
Definition: imgui_internal.h:659
ImPool::GetByIndex
T * GetByIndex(ImPoolIdx n)
Definition: imgui_internal.h:252
ImGuiContext::FontBaseSize
float FontBaseSize
Definition: imgui_internal.h:725
ImGui::RenderColorRectWithAlphaCheckerboard
IMGUI_API void RenderColorRectWithAlphaCheckerboard(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding=0.0f, int rounding_corners_flags=~0)
Definition: imgui_widgets.cpp:4038
ImRect::ClipWithFull
void ClipWithFull(const ImRect &r)
Definition: imgui_internal.h:470
ImGuiWindow::BeginCount
short BeginCount
Definition: imgui_internal.h:1111
ImGuiDir_None
@ ImGuiDir_None
Definition: imgui.h:891
ImGuiContext::FontSize
float FontSize
Definition: imgui_internal.h:724
ImGuiContext::NavScoringCount
int NavScoringCount
Definition: imgui_internal.h:785
ImGuiWindow::WindowPadding
ImVec2 WindowPadding
Definition: imgui_internal.h:1091
ImGuiInputTextState::ID
ImGuiID ID
Definition: imgui_internal.h:524
ImGuiNavMoveResult
Definition: imgui_internal.h:652
ImGui::PushItemFlag
IMGUI_API void PushItemFlag(ImGuiItemFlags option, bool enabled)
Definition: imgui.cpp:5571
ImPow
static float ImPow(float x, float y)
Definition: imgui_internal.h:203
ImGuiItemFlags_Disabled
@ ImGuiItemFlags_Disabled
Definition: imgui_internal.h:993
ImPool
Definition: imgui_internal.h:243
ImDrawDataBuilder::FlattenIntoSingleLayer
IMGUI_API void FlattenIntoSingleLayer()
Definition: imgui.cpp:3640
ImGuiStyleMod::VarIdx
ImGuiStyleVar VarIdx
Definition: imgui_internal.h:485
ImGui::ClosePopupToLevel
IMGUI_API void ClosePopupToLevel(int remaining, bool apply_focus_to_window_under)
Definition: imgui.cpp:6712
ImPool::GetByKey
T * GetByKey(ImGuiID key)
Definition: imgui_internal.h:251
ImGuiContext::SettingsHandlers
ImVector< ImGuiSettingsHandler > SettingsHandlers
Definition: imgui_internal.h:862
ImGuiWindowSettings::Size
ImVec2 Size
Definition: imgui_internal.h:556
ImGui::CollapseButton
IMGUI_API bool CollapseButton(ImGuiID id, const ImVec2 &pos)
Definition: imgui_widgets.cpp:680
ImGuiContext::FramerateSecPerFrameIdx
int FramerateSecPerFrameIdx
Definition: imgui_internal.h:874
ImGuiColumnsSet::IsBeingResized
bool IsBeingResized
Definition: imgui_internal.h:601
ImGui::SetCurrentFont
IMGUI_API void SetCurrentFont(ImFont *font)
Definition: imgui.cpp:5538
ImGuiNavDirSourceFlags_PadLStick
@ ImGuiNavDirSourceFlags_PadLStick
Definition: imgui_internal.h:405
min
int min(int a, int b)
ImGuiContext::NavInitResultRectRel
ImRect NavInitResultRectRel
Definition: imgui_internal.h:802
ImGuiTabBar::SelectedTabId
ImGuiID SelectedTabId
Definition: imgui_internal.h:1224
ImVec1::ImVec1
ImVec1(float _x)
Definition: imgui_internal.h:272
ImGuiContext::FrameCountEnded
int FrameCountEnded
Definition: imgui_internal.h:730
ImGui::RenderArrow
IMGUI_API void RenderArrow(ImVec2 pos, ImGuiDir dir, float scale=1.0f)
Definition: imgui.cpp:2338
ImGuiColumnsSet::Columns
ImVector< ImGuiColumnData > Columns
Definition: imgui_internal.h:608
ImGuiContext::DragDropPayload
ImGuiPayload DragDropPayload
Definition: imgui_internal.h:826
ImGuiTabBar::ID
ImGuiID ID
Definition: imgui_internal.h:1223
ImPool::ImPool
ImPool()
Definition: imgui_internal.h:249
ImGuiWindowTempData::GroupOffset
ImVec1 GroupOffset
Definition: imgui_internal.h:1043
ImGuiKey
int ImGuiKey
Definition: imgui.h:124
ImGui::UpdateMouseMovingWindowNewFrame
IMGUI_API void UpdateMouseMovingWindowNewFrame()
Definition: imgui.cpp:3036
ImGuiContext::NavMoveClipDir
ImGuiDir NavMoveClipDir
Definition: imgui_internal.h:808
ImDot
static float ImDot(const ImVec2 &a, const ImVec2 &b)
Definition: imgui_internal.h:234
ImGuiSliderFlags_None
@ ImGuiSliderFlags_None
Definition: imgui_internal.h:296
ImGuiInputTextState::CursorAnim
float CursorAnim
Definition: imgui_internal.h:532
ImGuiStb
Definition: imgui_internal.h:93
ImGuiInputSource_Mouse
@ ImGuiInputSource_Mouse
Definition: imgui_internal.h:373
ImGuiIO::Fonts
ImFontAtlas * Fonts
Definition: imgui.h:1290
ImGuiDir
int ImGuiDir
Definition: imgui.h:123
ImGuiWindow::MenuBarRect
ImRect MenuBarRect() const
Definition: imgui_internal.h:1177
ImGuiContext::ActiveIdIsJustActivated
bool ActiveIdIsJustActivated
Definition: imgui_internal.h:750
ImGuiTabItem::ImGuiTabItem
ImGuiTabItem()
Definition: imgui_internal.h:1216
ImGui::GetID
IMGUI_API ImGuiID GetID(const char *str_id)
Definition: imgui.cpp:6378
ImGuiNavLayer_Main
@ ImGuiNavLayer_Main
Definition: imgui_internal.h:428
ImGuiButtonFlags_AlignTextBaseLine
@ ImGuiButtonFlags_AlignTextBaseLine
Definition: imgui_internal.h:287
ImClamp
static T ImClamp(T v, T mn, T mx)
Definition: imgui_internal.h:218
NULL
#define NULL
ImPool::GetOrAddByKey
T * GetOrAddByKey(ImGuiID key)
Definition: imgui_internal.h:254
ImGuiNavLayer_Menu
@ ImGuiNavLayer_Menu
Definition: imgui_internal.h:429
ImGuiWindowTempData::ItemFlags
ImGuiItemFlags ItemFlags
Definition: imgui_internal.h:1033
ImGuiWindowTempData::NavHasScroll
bool NavHasScroll
Definition: imgui_internal.h:1024
ImGuiWindow::FocusIdxAllRequestCurrent
int FocusIdxAllRequestCurrent
Definition: imgui_internal.h:1156
ImFormatString
IMGUI_API int ImFormatString(char *buf, size_t buf_size, const char *fmt,...) IM_FMTARGS(3)
Definition: imgui.cpp:1387
ImRect::Expand
void Expand(const float amount)
Definition: imgui_internal.h:464
ImGuiInputTextState::UserCallback
ImGuiInputTextCallback UserCallback
Definition: imgui_internal.h:538
ImPool::Map
ImGuiStorage Map
Definition: imgui_internal.h:246
ImGuiContext::HoveredIdNotActiveTimer
float HoveredIdNotActiveTimer
Definition: imgui_internal.h:745
ImStrnicmp
IMGUI_API int ImStrnicmp(const char *str1, const char *str2, size_t count)
Definition: imgui.cpp:1271
ImGuiInputSource
ImGuiInputSource
Definition: imgui_internal.h:370
ImGuiContext::WindowsById
ImGuiStorage WindowsById
Definition: imgui_internal.h:736
ImGui::RenderArrowPointingAt
IMGUI_API void RenderArrowPointingAt(ImDrawList *draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col)
Definition: imgui_draw.cpp:2885
ImGuiContext::NavActivateDownId
ImGuiID NavActivateDownId
Definition: imgui_internal.h:777
ImGuiButtonFlags_NoNavFocus
@ ImGuiButtonFlags_NoNavFocus
Definition: imgui_internal.h:291
ImGuiContext::Font
ImFont * Font
Definition: imgui_internal.h:723
ImGuiContext::TooltipOverrideCount
int TooltipOverrideCount
Definition: imgui_internal.h:852
ImGuiNextWindowData::ContentSizeVal
ImVec2 ContentSizeVal
Definition: imgui_internal.h:678
ImGuiContext::HoveredIdPreviousFrame
ImGuiID HoveredIdPreviousFrame
Definition: imgui_internal.h:743
ImGuiNavDirSourceFlags_Keyboard
@ ImGuiNavDirSourceFlags_Keyboard
Definition: imgui_internal.h:403
ImGuiContext::Style
ImGuiStyle Style
Definition: imgui_internal.h:722
ImRotate
static ImVec2 ImRotate(const ImVec2 &v, float cos_a, float sin_a)
Definition: imgui_internal.h:235
ImGui::CalcItemSize
IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_x, float default_y)
Definition: imgui.cpp:2861
ImGuiContext::DragDropActive
bool DragDropActive
Definition: imgui_internal.h:821
ImGui::GetActiveID
ImGuiID GetActiveID()
Definition: imgui_internal.h:1298
ImGuiCond
int ImGuiCond
Definition: imgui.h:121
ImGui::RenderCheckMark
IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col, float sz)
Definition: imgui.cpp:2379
IM_NEW
#define IM_NEW(_TYPE)
Definition: imgui.h:1524
ImTriangleClosestPoint
IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p)
Definition: imgui.cpp:1248
ImParseFormatFindStart
const IMGUI_API char * ImParseFormatFindStart(const char *format)
Definition: imgui_widgets.cpp:2536
ImGui::PushColumnClipRect
IMGUI_API void PushColumnClipRect(int column_index=-1)
Definition: imgui.cpp:8142
ImGuiStyleMod::BackupFloat
float BackupFloat[2]
Definition: imgui_internal.h:486
ImVec4::z
float z
Definition: imgui.h:178
ImGuiStyleMod::ImGuiStyleMod
ImGuiStyleMod(ImGuiStyleVar idx, float v)
Definition: imgui_internal.h:488
ImGuiPlotType_Histogram
@ ImGuiPlotType_Histogram
Definition: imgui_internal.h:367
ImGuiContext::PlatformImePos
ImVec2 PlatformImePos
Definition: imgui_internal.h:856
ImGuiCol
int ImGuiCol
Definition: imgui.h:120
ImGuiWindow::Flags
ImGuiWindowFlags Flags
Definition: imgui_internal.h:1084
ImGuiSettingsHandler::TypeHash
ImGuiID TypeHash
Definition: imgui_internal.h:565
ImGuiNavMoveFlags_AllowCurrentNavId
@ ImGuiNavMoveFlags_AllowCurrentNavId
Definition: imgui_internal.h:415
ImRect::Min
ImVec2 Min
Definition: imgui_internal.h:443
ImGuiNavInput
int ImGuiNavInput
Definition: imgui.h:125
ImStrdup
IMGUI_API char * ImStrdup(const char *str)
Definition: imgui.cpp:1285
ImGui::FindWindowByName
IMGUI_API ImGuiWindow * FindWindowByName(const char *name)
Definition: imgui.cpp:4387
ImGuiContext::NavWindowingTimer
float NavWindowingTimer
Definition: imgui_internal.h:789
ImGuiContext::ActiveIdPreviousFrameWindow
ImGuiWindow * ActiveIdPreviousFrameWindow
Definition: imgui_internal.h:758
ImGuiTabBar::LastTabItemIdx
short LastTabItemIdx
Definition: imgui_internal.h:1240
ImGuiWindowTempData::CurrentLineSize
ImVec2 CurrentLineSize
Definition: imgui_internal.h:1008
ImGuiSliderFlags_
ImGuiSliderFlags_
Definition: imgui_internal.h:294
ImGuiColorMod::Col
ImGuiCol Col
Definition: imgui_internal.h:478
ImVector::index_from_ptr
int index_from_ptr(const T *it) const
Definition: imgui.h:1214
ImGuiItemHoveredDataBackup
Definition: imgui_internal.h:1181
ImGuiNextWindowData::FocusCond
ImGuiCond FocusCond
Definition: imgui_internal.h:673
ImGuiContext::DragDropAcceptIdCurrRectSurface
float DragDropAcceptIdCurrRectSurface
Definition: imgui_internal.h:830
ImGuiInputSource_Nav
@ ImGuiInputSource_Nav
Definition: imgui_internal.h:374
ImGuiContext::OverlayDrawList
ImDrawList OverlayDrawList
Definition: imgui_internal.h:817
ImGuiWindow::RootWindow
ImGuiWindow * RootWindow
Definition: imgui_internal.h:1144
ImGuiContext::ActiveIdPreviousFrameHasBeenEdited
bool ActiveIdPreviousFrameHasBeenEdited
Definition: imgui_internal.h:754
ImGuiTabBar::NextSelectedTabId
ImGuiID NextSelectedTabId
Definition: imgui_internal.h:1225
ImGui::MarkItemEdited
IMGUI_API void MarkItemEdited(ImGuiID id)
Definition: imgui.cpp:2646
ImGui::GetItemID
ImGuiID GetItemID()
Definition: imgui_internal.h:1297
ImGuiContext::ActiveId
ImGuiID ActiveId
Definition: imgui_internal.h:746
ImGuiNavMoveResult::Clear
void Clear()
Definition: imgui_internal.h:662
ImGuiWindowFlags
int ImGuiWindowFlags
Definition: imgui.h:144
ImRect::TranslateY
void TranslateY(float dy)
Definition: imgui_internal.h:468
ImGui::BeginDragDropTargetCustom
IMGUI_API bool BeginDragDropTargetCustom(const ImRect &bb, ImGuiID id)
Definition: imgui.cpp:8490
ImGuiContext::WantCaptureMouseNextFrame
int WantCaptureMouseNextFrame
Definition: imgui_internal.h:876
ImGuiButtonFlags_PressedOnClick
@ ImGuiButtonFlags_PressedOnClick
Definition: imgui_internal.h:280
s
XmlRpcServer s
ImGuiContext::FrameCount
int FrameCount
Definition: imgui_internal.h:729
ImGuiSeparatorFlags
int ImGuiSeparatorFlags
Definition: imgui_internal.h:85
ImGuiTabBar::PrevFrameVisible
int PrevFrameVisible
Definition: imgui_internal.h:1228
ImGuiWindowTempData::NavLayerActiveMaskNext
int NavLayerActiveMaskNext
Definition: imgui_internal.h:1022
ImCos
static float ImCos(float x)
Definition: imgui_internal.h:207
ImGuiContext::LastActiveId
ImGuiID LastActiveId
Definition: imgui_internal.h:760
ImGuiNavMoveFlags_WrapY
@ ImGuiNavMoveFlags_WrapY
Definition: imgui_internal.h:414
ImGuiNextWindowData::SizeConstraintCond
ImGuiCond SizeConstraintCond
Definition: imgui_internal.h:672
ImGuiColumnData::ImGuiColumnData
ImGuiColumnData()
Definition: imgui_internal.h:593
ImGuiButtonFlags_Disabled
@ ImGuiButtonFlags_Disabled
Definition: imgui_internal.h:286
ImGuiTabBarFlags
int ImGuiTabBarFlags
Definition: imgui.h:141
ImGuiPopupRef::OpenFrameCount
int OpenFrameCount
Definition: imgui_internal.h:580
ImGuiColumnsSet::ID
ImGuiID ID
Definition: imgui_internal.h:598
ImGuiWindow::SizeContents
ImVec2 SizeContents
Definition: imgui_internal.h:1089
ImGuiContext::NavAnyRequest
bool NavAnyRequest
Definition: imgui_internal.h:798
ImGuiTabBar::ReorderRequestDir
int ReorderRequestDir
Definition: imgui_internal.h:1237
ImGuiWindowTempData::NavLayerCurrent
ImGuiNavLayer NavLayerCurrent
Definition: imgui_internal.h:1019
ImGuiWindow::SetWindowSizeAllowFlags
ImGuiCond SetWindowSizeAllowFlags
Definition: imgui_internal.h:1122
ImGuiInputSource_None
@ ImGuiInputSource_None
Definition: imgui_internal.h:372
ImGuiNextWindowData::MenuBarOffsetMinVal
ImVec2 MenuBarOffsetMinVal
Definition: imgui_internal.h:684
ImGui::ItemHoverable
IMGUI_API bool ItemHoverable(const ImRect &bb, ImGuiID id)
Definition: imgui.cpp:2797
ImGuiWindowTempData::ColumnsOffset
ImVec1 ColumnsOffset
Definition: imgui_internal.h:1044
ImGuiContext::DragSpeedDefaultRatio
float DragSpeedDefaultRatio
Definition: imgui_internal.h:850
ImTriangleBarycentricCoords
IMGUI_API void ImTriangleBarycentricCoords(const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p, float &out_u, float &out_v, float &out_w)
Definition: imgui.cpp:1237
ImGuiNavMoveFlags_AlsoScoreVisibleSet
@ ImGuiNavMoveFlags_AlsoScoreVisibleSet
Definition: imgui_internal.h:416
ImGuiGroupData::BackupCurrentLineTextBaseOffset
float BackupCurrentLineTextBaseOffset
Definition: imgui_internal.h:500
ImGuiWindow::SetWindowPosPivot
ImVec2 SetWindowPosPivot
Definition: imgui_internal.h:1125
ImGuiWindowTempData::PrevLineTextBaseOffset
float PrevLineTextBaseOffset
Definition: imgui_internal.h:1011
ImParseFormatPrecision
IMGUI_API int ImParseFormatPrecision(const char *format, int default_value)
Definition: imgui_widgets.cpp:2585
ImGuiInputTextState::CursorFollow
bool CursorFollow
Definition: imgui_internal.h:533
ImUpperPowerOfTwo
static int ImUpperPowerOfTwo(int v)
Definition: imgui_internal.h:150
ImGuiWindowTempData::LastItemDisplayRect
ImRect LastItemDisplayRect
Definition: imgui_internal.h:1018
ImGuiContext::ActiveIdPreviousFrame
ImGuiID ActiveIdPreviousFrame
Definition: imgui_internal.h:747
ImGuiContext::DragDropPayloadBufHeap
ImVector< unsigned char > DragDropPayloadBufHeap
Definition: imgui_internal.h:834
ImGuiContext::SettingsDirtyTimer
float SettingsDirtyTimer
Definition: imgui_internal.h:860
ImGuiNextWindowData::PosPivotVal
ImVec2 PosPivotVal
Definition: imgui_internal.h:676
ImVec1::x
float x
Definition: imgui_internal.h:270
ImGuiSettingsHandler::UserData
void * UserData
Definition: imgui_internal.h:569
ImGuiContext::NavWindow
ImGuiWindow * NavWindow
Definition: imgui_internal.h:774
ImGuiNextWindowData::ImGuiNextWindowData
ImGuiNextWindowData()
Definition: imgui_internal.h:686
ImGuiContext::FrameScopePushedImplicitWindow
bool FrameScopePushedImplicitWindow
Definition: imgui_internal.h:719
ImGuiContext::SettingsWindows
ImVector< ImGuiWindowSettings > SettingsWindows
Definition: imgui_internal.h:863
ImGuiInputTextState::CursorAnimReset
void CursorAnimReset()
Definition: imgui_internal.h:542
ImGuiTabBarFlags_DockNode
@ ImGuiTabBarFlags_DockNode
Definition: imgui_internal.h:1199
ImGuiWindow::SettingsIdx
int SettingsIdx
Definition: imgui_internal.h:1139
ImFloor
static float ImFloor(float f)
Definition: imgui_internal.h:232
ImGuiContext::NavMoveResultLocal
ImGuiNavMoveResult NavMoveResultLocal
Definition: imgui_internal.h:809
ImGuiContext::NextWindowData
ImGuiNextWindowData NextWindowData
Definition: imgui_internal.h:769
ImGui::FindWindowByID
IMGUI_API ImGuiWindow * FindWindowByID(ImGuiID id)
Definition: imgui.cpp:4381
ImGuiWindow::ParentWindow
ImGuiWindow * ParentWindow
Definition: imgui_internal.h:1143
ImDrawList
Definition: imgui.h:1787
ImGuiColorEditFlags__OptionsDefault
@ ImGuiColorEditFlags__OptionsDefault
Definition: imgui.h:1116
ImTextStrToUtf8
IMGUI_API int ImTextStrToUtf8(char *buf, int buf_size, const ImWchar *in_text, const ImWchar *in_text_end)
Definition: imgui.cpp:1678
ImGuiContext::InputTextPasswordFont
ImFont InputTextPasswordFont
Definition: imgui_internal.h:844
ImRect::IsInverted
bool IsInverted() const
Definition: imgui_internal.h:472
ImGuiInputTextState::UserCallbackData
void * UserCallbackData
Definition: imgui_internal.h:539
ImGuiWindow::HiddenFramesRegular
int HiddenFramesRegular
Definition: imgui_internal.h:1119
ImFormatStringV
IMGUI_API int ImFormatStringV(char *buf, size_t buf_size, const char *fmt, va_list args) IM_FMTLIST(3)
Definition: imgui.cpp:1405
ImGui::CalcTypematicPressedRepeatAmount
IMGUI_API int CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate)
Definition: imgui.cpp:3970
ImGuiItemHoveredDataBackup::LastItemDisplayRect
ImRect LastItemDisplayRect
Definition: imgui_internal.h:1186
ImGuiContext::HoveredIdTimer
float HoveredIdTimer
Definition: imgui_internal.h:744
ImGuiSelectableFlagsPrivate_
ImGuiSelectableFlagsPrivate_
Definition: imgui_internal.h:317
ImGuiContext::NavNextActivateId
ImGuiID NavNextActivateId
Definition: imgui_internal.h:782
ImGuiNavLayer_COUNT
@ ImGuiNavLayer_COUNT
Definition: imgui_internal.h:430
ImRect::GetSize
ImVec2 GetSize() const
Definition: imgui_internal.h:452
ImGuiWindow::HasCloseButton
bool HasCloseButton
Definition: imgui_internal.h:1110
ImGuiWindow::Collapsed
bool Collapsed
Definition: imgui_internal.h:1105
ImGuiContext::LastActiveIdTimer
float LastActiveIdTimer
Definition: imgui_internal.h:761
ImGuiInputReadMode_Repeat
@ ImGuiInputReadMode_Repeat
Definition: imgui_internal.h:386
ImGuiWindow::FocusIdxAllRequestNext
int FocusIdxAllRequestNext
Definition: imgui_internal.h:1158
ImGuiContext::ActiveIdHasBeenEdited
bool ActiveIdHasBeenEdited
Definition: imgui_internal.h:752
ImGui::BeginColumns
IMGUI_API void BeginColumns(const char *str_id, int count, ImGuiColumnsFlags flags=0)
Definition: imgui.cpp:8164
ImGuiContext::FrameCountRendered
int FrameCountRendered
Definition: imgui_internal.h:731
ImGuiAxis_X
@ ImGuiAxis_X
Definition: imgui_internal.h:360
ImDrawList::_Data
const ImDrawListSharedData * _Data
Definition: imgui.h:1796
ImGuiWindowTempData::StateStorage
ImGuiStorage * StateStorage
Definition: imgui_internal.h:1028
ImGuiIO::NavInputs
float NavInputs[ImGuiNavInput_COUNT]
Definition: imgui.h:1350
ImGuiWindowTempData::TextWrapPosStack
ImVector< float > TextWrapPosStack
Definition: imgui_internal.h:1038
ImGuiInputTextState::ScrollX
float ScrollX
Definition: imgui_internal.h:530
ImGuiWindowTempData::CursorStartPos
ImVec2 CursorStartPos
Definition: imgui_internal.h:1006
ImGuiWindow::SetWindowCollapsedAllowFlags
ImGuiCond SetWindowCollapsedAllowFlags
Definition: imgui_internal.h:1123
ImGuiID
unsigned int ImGuiID
Definition: imgui.h:118
ImGuiTabBarFlags_SaveSettings
@ ImGuiTabBarFlags_SaveSettings
Definition: imgui_internal.h:1202
ImGuiNavHighlightFlags
int ImGuiNavHighlightFlags
Definition: imgui_internal.h:82
ImGui::TabBarFindTabByID
IMGUI_API ImGuiTabItem * TabBarFindTabByID(ImGuiTabBar *tab_bar, ImGuiID tab_id)
Definition: imgui_widgets.cpp:6089
ImGuiColumnsSet::LineMinY
float LineMinY
Definition: imgui_internal.h:605
ImGuiWindowTempData::ImGuiWindowTempData
ImGuiWindowTempData()
Definition: imgui_internal.h:1047
ImGuiNavLayer
ImGuiNavLayer
Definition: imgui_internal.h:426
ImGui::NavMoveRequestCancel
IMGUI_API void NavMoveRequestCancel()
Definition: imgui.cpp:7216
ImGuiColumnsFlags_NoBorder
@ ImGuiColumnsFlags_NoBorder
Definition: imgui_internal.h:310
ImVector
Definition: imgui.h:1166
ImGuiColumnsSet::LineMaxY
float LineMaxY
Definition: imgui_internal.h:605
ImGui::IsDragDropPayloadBeingAccepted
IMGUI_API bool IsDragDropPayloadBeingAccepted()
Definition: imgui.cpp:8542
ImGuiTabBar
Definition: imgui_internal.h:1220
ImGuiNavDirSourceFlags_None
@ ImGuiNavDirSourceFlags_None
Definition: imgui_internal.h:402
ImGui::GetDefaultFont
ImFont * GetDefaultFont()
Definition: imgui_internal.h:1277
ImGui::ClearActiveID
IMGUI_API void ClearActiveID()
Definition: imgui.cpp:2617
ImPool::Data
ImVector< T > Data
Definition: imgui_internal.h:245
ImGuiContext::NavDisableMouseHover
bool NavDisableMouseHover
Definition: imgui_internal.h:797
ImGuiContext::NavId
ImGuiID NavId
Definition: imgui_internal.h:775
ImGui::RenderText
IMGUI_API void RenderText(ImVec2 pos, const char *text, const char *text_end=NULL, bool hide_text_after_hash=true)
Definition: imgui.cpp:2224
ImGuiItemHoveredDataBackup::ImGuiItemHoveredDataBackup
ImGuiItemHoveredDataBackup()
Definition: imgui_internal.h:1188
ImFontAtlas
Definition: imgui.h:1974
ImGui::DragBehavior
IMGUI_API bool DragBehavior(ImGuiID id, ImGuiDataType data_type, void *v, float v_speed, const void *v_min, const void *v_max, const char *format, float power, ImGuiDragFlags flags)
Definition: imgui_widgets.cpp:1821
ImGuiSliderFlags
int ImGuiSliderFlags
Definition: imgui_internal.h:86
ImGui::SliderBehaviorT
IMGUI_API bool SliderBehaviorT(const ImRect &bb, ImGuiID id, ImGuiDataType data_type, T *v, const T v_min, const T v_max, const char *format, float power, ImGuiSliderFlags flags, ImRect *out_grab_bb)
ImVec2
Definition: imgui.h:164
ImGuiNextWindowData::BgAlphaCond
ImGuiCond BgAlphaCond
Definition: imgui_internal.h:674
ImGui::BringWindowToDisplayFront
IMGUI_API void BringWindowToDisplayFront(ImGuiWindow *window)
Definition: imgui.cpp:5414
ImGuiContext::DragDropAcceptFlags
ImGuiDragDropFlags DragDropAcceptFlags
Definition: imgui_internal.h:829
ImGuiStorage::Data
ImVector< Pair > Data
Definition: imgui.h:1607
ImGuiTabItem::WidthContents
float WidthContents
Definition: imgui_internal.h:1214
ImGuiContext::TabBars
ImPool< ImGuiTabBar > TabBars
Definition: imgui_internal.h:838
ImGuiTabBarSortItem::Width
float Width
Definition: imgui_internal.h:708
ImGui::RenderTextClipped
IMGUI_API void RenderTextClipped(const ImVec2 &pos_min, const ImVec2 &pos_max, const char *text, const char *text_end, const ImVec2 *text_size_if_known, const ImVec2 &align=ImVec2(0, 0), const ImRect *clip_rect=NULL)
Definition: imgui.cpp:2296
ImGuiTabBar::ContentsHeight
float ContentsHeight
Definition: imgui_internal.h:1230
ImGuiContext::NavDisableHighlight
bool NavDisableHighlight
Definition: imgui_internal.h:796
ImRect::Max
ImVec2 Max
Definition: imgui_internal.h:444
ImParseFormatFindEnd
const IMGUI_API char * ImParseFormatFindEnd(const char *format)
Definition: imgui_widgets.cpp:2549
ImGuiWindowFlags_MenuBar
@ ImGuiWindowFlags_MenuBar
Definition: imgui.h:696
ImGuiPopupPositionPolicy_ComboBox
@ ImGuiPopupPositionPolicy_ComboBox
Definition: imgui_internal.h:436
ImGuiWindowTempData::CursorPos
ImVec2 CursorPos
Definition: imgui_internal.h:1004
ImGui::TabItemCalcSize
IMGUI_API ImVec2 TabItemCalcSize(const char *label, bool has_close_button)
Definition: imgui_widgets.cpp:6449
ImGuiWindow::FocusIdxAllCounter
int FocusIdxAllCounter
Definition: imgui_internal.h:1154
ImGuiContext::DragDropAcceptIdPrev
ImGuiID DragDropAcceptIdPrev
Definition: imgui_internal.h:832
ImGui::RenderNavHighlight
IMGUI_API void RenderNavHighlight(const ImRect &bb, ImGuiID id, ImGuiNavHighlightFlags flags=ImGuiNavHighlightFlags_TypeDefault)
Definition: imgui.cpp:2397
ImGuiButtonFlags_PressedOnRelease
@ ImGuiButtonFlags_PressedOnRelease
Definition: imgui_internal.h:281
ImGuiWindowTempData::ColumnsSet
ImGuiColumnsSet * ColumnsSet
Definition: imgui_internal.h:1045
ImRect::Overlaps
bool Overlaps(const ImRect &r) const
Definition: imgui_internal.h:461
ImPool::~ImPool
~ImPool()
Definition: imgui_internal.h:250
ImGuiContext::DimBgRatio
float DimBgRatio
Definition: imgui_internal.h:816
ImGuiContext::NavWindowingTarget
ImGuiWindow * NavWindowingTarget
Definition: imgui_internal.h:786
ImGuiContext::LogAutoExpandMaxDepth
int LogAutoExpandMaxDepth
Definition: imgui_internal.h:870
ImGuiButtonFlags
int ImGuiButtonFlags
Definition: imgui_internal.h:79
ImGuiWindowTempData::NavLayerActiveMask
int NavLayerActiveMask
Definition: imgui_internal.h:1021
ImPool::Remove
void Remove(ImGuiID key, ImPoolIdx idx)
Definition: imgui_internal.h:258
ImGuiWindow::SizeFull
ImVec2 SizeFull
Definition: imgui_internal.h:1087
ImGui::PlotEx
IMGUI_API void 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 graph_size)
Definition: imgui_widgets.cpp:5218
ImGuiWindowTempData::GroupStack
ImVector< ImGuiGroupData > GroupStack
Definition: imgui_internal.h:1039
ImGuiWindowTempData::NavHideHighlightOneFrame
bool NavHideHighlightOneFrame
Definition: imgui_internal.h:1023
ImGuiContext::PrivateClipboard
ImVector< char > PrivateClipboard
Definition: imgui_internal.h:853
ImGuiInputTextState::CurLenW
int CurLenW
Definition: imgui_internal.h:528
ImGuiContext::CurrentWindowStack
ImVector< ImGuiWindow * > CurrentWindowStack
Definition: imgui_internal.h:735
ImMin
static T ImMin(T lhs, T rhs)
Definition: imgui_internal.h:216
ImGuiInputSource_NavGamepad
@ ImGuiInputSource_NavGamepad
Definition: imgui_internal.h:376
ImGui::SplitterBehavior
IMGUI_API bool SplitterBehavior(const ImRect &bb, ImGuiID id, ImGuiAxis axis, float *size1, float *size2, float min_size1, float min_size2, float hover_extend=0.0f, float hover_visibility_delay=0.0f)
Definition: imgui_widgets.cpp:1195
ImGuiWindow::AutoFitOnlyGrows
bool AutoFitOnlyGrows
Definition: imgui_internal.h:1116
ImGuiTabBar::Tabs
ImVector< ImGuiTabItem > Tabs
Definition: imgui_internal.h:1222
ImGui::RenderMouseCursor
IMGUI_API void RenderMouseCursor(ImDrawList *draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor=ImGuiMouseCursor_Arrow)
Definition: imgui_draw.cpp:2859
ImGuiNavMoveFlags_None
@ ImGuiNavMoveFlags_None
Definition: imgui_internal.h:410
ImRect::TranslateX
void TranslateX(float dx)
Definition: imgui_internal.h:467
ImGuiNavForward
ImGuiNavForward
Definition: imgui_internal.h:419
ImGuiInputTextState
Definition: imgui_internal.h:522
ImGui::GetCurrentWindow
ImGuiWindow * GetCurrentWindow()
Definition: imgui_internal.h:1258
ImGuiTreeNodeFlags
int ImGuiTreeNodeFlags
Definition: imgui.h:143
ImGuiColorEditFlags
int ImGuiColorEditFlags
Definition: imgui.h:132
ImGui::GetHoveredID
IMGUI_API ImGuiID GetHoveredID()
Definition: imgui.cpp:2631
ImGuiColumnsSet::Count
int Count
Definition: imgui_internal.h:603
ImDrawListSharedData::FontSize
float FontSize
Definition: imgui_internal.h:632
ImStrbolW
const IMGUI_API ImWchar * ImStrbolW(const ImWchar *buf_mid_line, const ImWchar *buf_begin)
Definition: imgui.cpp:1327
ImDrawListSharedData::CurveTessellationTol
float CurveTessellationTol
Definition: imgui_internal.h:633
ImGuiInputTextState::BufCapacityA
int BufCapacityA
Definition: imgui_internal.h:529
ImGui::IsPopupOpen
IMGUI_API bool IsPopupOpen(const char *str_id)
Definition: imgui.cpp:6594
ImGuiItemFlags_NoNavDefaultFocus
@ ImGuiItemFlags_NoNavDefaultFocus
Definition: imgui_internal.h:995
ImGuiInputReadMode_RepeatFast
@ ImGuiInputReadMode_RepeatFast
Definition: imgui_internal.h:388
ImGuiWindowTempData::LastItemStatusFlags
ImGuiItemStatusFlags LastItemStatusFlags
Definition: imgui_internal.h:1016
f
f
ImFontAtlasBuildRegisterDefaultCustomRects
IMGUI_API void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas *atlas)
Definition: imgui_draw.cpp:1955
ImGui::ArrowButtonEx
IMGUI_API bool ArrowButtonEx(const char *str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags)
Definition: imgui_widgets.cpp:615
ImGuiContext::FontStack
ImVector< ImFont * > FontStack
Definition: imgui_internal.h:766
ImGui::CalcWrapWidthForPos
IMGUI_API float CalcWrapWidthForPos(const ImVec2 &pos, float wrap_pos_x)
Definition: imgui.cpp:2874
ImSaturate
static float ImSaturate(float f)
Definition: imgui_internal.h:228
ImGuiTabBar::VisibleTabWasSubmitted
bool VisibleTabWasSubmitted
Definition: imgui_internal.h:1239
ImGuiPayload
Definition: imgui.h:1450
ImRect::Translate
void Translate(const ImVec2 &d)
Definition: imgui_internal.h:466
ImGuiNavHighlightFlags_
ImGuiNavHighlightFlags_
Definition: imgui_internal.h:391
ImGuiStorage::Clear
void Clear()
Definition: imgui.h:1612
ImGuiContext::NextTreeNodeOpenVal
bool NextTreeNodeOpenVal
Definition: imgui_internal.h:770
ImGui::FindBestWindowPosForPopupEx
IMGUI_API ImVec2 FindBestWindowPosForPopupEx(const ImVec2 &ref_pos, const ImVec2 &size, ImGuiDir *last_dir, const ImRect &r_outer, const ImRect &r_avoid, ImGuiPopupPositionPolicy policy=ImGuiPopupPositionPolicy_Default)
Definition: imgui.cpp:6873
ImGuiWindow::SkipItems
bool SkipItems
Definition: imgui_internal.h:1107
ImGuiWindow::ItemWidthDefault
float ItemWidthDefault
Definition: imgui_internal.h:1134
ImGuiContext::PlatformImeLastPos
ImVec2 PlatformImeLastPos
Definition: imgui_internal.h:856
ImGuiContext::IO
ImGuiIO IO
Definition: imgui_internal.h:721
ImGuiWindowTempData::PrevLineSize
ImVec2 PrevLineSize
Definition: imgui_internal.h:1010
ImGuiWindow::FontWindowScale
float FontWindowScale
Definition: imgui_internal.h:1138
ImGuiTextBuffer
Definition: imgui.h:1571
ImGuiContext::NavMoveRequestFlags
ImGuiNavMoveFlags NavMoveRequestFlags
Definition: imgui_internal.h:805
ImGui::IsKeyPressed
IMGUI_API bool IsKeyPressed(int user_key_index, bool repeat=true)
Definition: imgui.cpp:3989
ImGui::IsClippedEx
IMGUI_API bool IsClippedEx(const ImRect &bb, ImGuiID id, bool clip_even_when_logged)
Definition: imgui.cpp:2819
ImGuiContext::ActiveIdAllowOverlap
bool ActiveIdAllowOverlap
Definition: imgui_internal.h:751
ImCharIsBlankW
static bool ImCharIsBlankW(unsigned int c)
Definition: imgui_internal.h:148
ImVec4::y
float y
Definition: imgui.h:178
ImCeil
static float ImCeil(float x)
Definition: imgui_internal.h:213
ImGuiWindow::SetWindowPosVal
ImVec2 SetWindowPosVal
Definition: imgui_internal.h:1124
ImDrawDataBuilder::Clear
void Clear()
Definition: imgui_internal.h:647
imstb_textedit.h
ImGuiColumnsSet::Flags
ImGuiColumnsFlags Flags
Definition: imgui_internal.h:599
ImGui::GetWindowScrollMaxX
IMGUI_API float GetWindowScrollMaxX(ImGuiWindow *window)
Definition: imgui.cpp:4518
ImGuiNextWindowData::SizeConstraintRect
ImRect SizeConstraintRect
Definition: imgui_internal.h:680
IM_FMTLIST
#define IM_FMTLIST(FMT)
Definition: imgui.h:71
ImGuiInputTextState::SelectAll
void SelectAll()
Definition: imgui_internal.h:546
ImGuiContext::NextTreeNodeOpenCond
ImGuiCond NextTreeNodeOpenCond
Definition: imgui_internal.h:771
ImRect::GetBR
ImVec2 GetBR() const
Definition: imgui_internal.h:458
ImGuiInputTextCallback
int(* ImGuiInputTextCallback)(ImGuiInputTextCallbackData *data)
Definition: imgui.h:145
ImRect::ImRect
ImRect(float x1, float y1, float x2, float y2)
Definition: imgui_internal.h:449
ImGuiWindowTempData::TextWrapPos
float TextWrapPos
Definition: imgui_internal.h:1035
ImDrawListSharedData::TexUvWhitePixel
ImVec2 TexUvWhitePixel
Definition: imgui_internal.h:630
ImGuiColumnData::OffsetNorm
float OffsetNorm
Definition: imgui_internal.h:588
ImGuiTabBar::Flags
ImGuiTabBarFlags Flags
Definition: imgui_internal.h:1235
ImRect::Expand
void Expand(const ImVec2 &amount)
Definition: imgui_internal.h:465
ImGuiInputTextState::StbState
ImGuiStb::STB_TexteditState StbState
Definition: imgui_internal.h:531
ImGuiGroupData::BackupLogLinePosY
float BackupLogLinePosY
Definition: imgui_internal.h:501
ImGuiPopupPositionPolicy
ImGuiPopupPositionPolicy
Definition: imgui_internal.h:433
ImGuiInputTextState::CursorClamp
void CursorClamp()
Definition: imgui_internal.h:543
ImGuiContext::NavWindowingTargetAnim
ImGuiWindow * NavWindowingTargetAnim
Definition: imgui_internal.h:787
ImGuiSelectableFlags_PressedOnClick
@ ImGuiSelectableFlags_PressedOnClick
Definition: imgui_internal.h:321
ImGuiTabBar::ImGuiTabBar
ImGuiTabBar()
Definition: imgui_widgets.cpp:5795
ImGuiWindow::Scroll
ImVec2 Scroll
Definition: imgui_internal.h:1097
ImVector::Data
T * Data
Definition: imgui.h:1170
ImGuiNavMoveFlags_WrapX
@ ImGuiNavMoveFlags_WrapX
Definition: imgui_internal.h:413
ImGuiContext::NavJustMovedToId
ImGuiID NavJustMovedToId
Definition: imgui_internal.h:781
ImGui::ShadeVertsLinearColorGradientKeepAlpha
IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawList *draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1)
Definition: imgui_draw.cpp:1301
ImGuiButtonFlags_Repeat
@ ImGuiButtonFlags_Repeat
Definition: imgui_internal.h:278
ImGuiWindow::TitleBarHeight
float TitleBarHeight() const
Definition: imgui_internal.h:1174
ImStrncpy
IMGUI_API void ImStrncpy(char *dst, const char *src, size_t count)
Definition: imgui.cpp:1278
ImGuiWindow::ID
ImGuiID ID
Definition: imgui_internal.h:1083
ImGuiWindowTempData::TreeDepth
int TreeDepth
Definition: imgui_internal.h:1013
ImGuiItemStatusFlags_None
@ ImGuiItemStatusFlags_None
Definition: imgui_internal.h:336
ImGuiWindow::FocusIdxTabRequestCurrent
int FocusIdxTabRequestCurrent
Definition: imgui_internal.h:1157
ImGuiWindowTempData::LogLinePosY
float LogLinePosY
Definition: imgui_internal.h:1012
ImGuiContext::NavWindowingList
ImGuiWindow * NavWindowingList
Definition: imgui_internal.h:788
ImGuiStyleMod::BackupInt
int BackupInt[2]
Definition: imgui_internal.h:486
ImVector::clear
void clear()
Definition: imgui.h:1189
ImRect::Floor
void Floor()
Definition: imgui_internal.h:471
ImAcos
static float ImAcos(float x)
Definition: imgui_internal.h:209
ImGuiButtonFlags_NoKeyModifiers
@ ImGuiButtonFlags_NoKeyModifiers
Definition: imgui_internal.h:288
ImGuiColumnData::OffsetNormBeforeResize
float OffsetNormBeforeResize
Definition: imgui_internal.h:589
operator*
b2Vec2 operator*(float s, const b2Vec2 &a)
Definition: b2_math.h:446
ImGuiNavDirSourceFlags_PadDPad
@ ImGuiNavDirSourceFlags_PadDPad
Definition: imgui_internal.h:404
ImGuiContext::Windows
ImVector< ImGuiWindow * > Windows
Definition: imgui_internal.h:732
ImGuiNavDirSourceFlags_
ImGuiNavDirSourceFlags_
Definition: imgui_internal.h:400
ImGuiDataType
int ImGuiDataType
Definition: imgui.h:122
ImGuiContext::HoveredRootWindow
ImGuiWindow * HoveredRootWindow
Definition: imgui_internal.h:740
ImGuiWindowTempData::CursorMaxPos
ImVec2 CursorMaxPos
Definition: imgui_internal.h:1007
ImGuiColumnsFlags_NoForceWithinWindow
@ ImGuiColumnsFlags_NoForceWithinWindow
Definition: imgui_internal.h:313
ImGuiColumnsFlags_NoResize
@ ImGuiColumnsFlags_NoResize
Definition: imgui_internal.h:311
ImGuiInputSource_COUNT
@ ImGuiInputSource_COUNT
Definition: imgui_internal.h:377
ImGuiItemFlags
int ImGuiItemFlags
Definition: imgui_internal.h:80
ImGuiNavForward_ForwardActive
@ ImGuiNavForward_ForwardActive
Definition: imgui_internal.h:423
ImGuiNavMoveFlags_LoopX
@ ImGuiNavMoveFlags_LoopX
Definition: imgui_internal.h:411
ImGuiPopupRef
Definition: imgui_internal.h:575
IM_FMTARGS
#define IM_FMTARGS(FMT)
Definition: imgui.h:70
ImGui::ButtonEx
IMGUI_API bool ButtonEx(const char *label, const ImVec2 &size_arg=ImVec2(0, 0), ImGuiButtonFlags flags=0)
Definition: imgui_widgets.cpp:534
ImGuiNavMoveFlags_LoopY
@ ImGuiNavMoveFlags_LoopY
Definition: imgui_internal.h:412
ImGuiButtonFlags_PressedOnDragDropHold
@ ImGuiButtonFlags_PressedOnDragDropHold
Definition: imgui_internal.h:290
ImGuiContext::WindowsActiveCount
int WindowsActiveCount
Definition: imgui_internal.h:737
ImGuiContext::WantCaptureKeyboardNextFrame
int WantCaptureKeyboardNextFrame
Definition: imgui_internal.h:877
ImGuiWindow::AutoFitFramesY
int AutoFitFramesY
Definition: imgui_internal.h:1115
ImGuiInputTextState::HasSelection
bool HasSelection() const
Definition: imgui_internal.h:544
ImGuiTabItem::Width
float Width
Definition: imgui_internal.h:1213
ImHash
IMGUI_API ImU32 ImHash(const void *data, int data_size, ImU32 seed=0)
Definition: imgui.cpp:1425
void
typedef void(GLAD_API_PTR *GLDEBUGPROC)(GLenum source
ImGuiWindow::SizeFullAtLastBegin
ImVec2 SizeFullAtLastBegin
Definition: imgui_internal.h:1088
ImGuiNextWindowData::CollapsedCond
ImGuiCond CollapsedCond
Definition: imgui_internal.h:671
ImGuiPopupRef::Window
ImGuiWindow * Window
Definition: imgui_internal.h:578
ImGui::UpdateWindowParentAndRootLinks
IMGUI_API void UpdateWindowParentAndRootLinks(ImGuiWindow *window, ImGuiWindowFlags flags, ImGuiWindow *parent_window)
Definition: imgui.cpp:4717
ImGuiPopupRef::OpenMousePos
ImVec2 OpenMousePos
Definition: imgui_internal.h:583
ImDrawData
Definition: imgui.h:1879
ImGui::FocusPreviousWindowIgnoringOne
IMGUI_API void FocusPreviousWindowIgnoringOne(ImGuiWindow *ignore_window)
Definition: imgui.cpp:5479
ImGuiWindow::FocusIdxTabRequestNext
int FocusIdxTabRequestNext
Definition: imgui_internal.h:1159
ImRect::ImRect
ImRect(const ImVec2 &min, const ImVec2 &max)
Definition: imgui_internal.h:447
ImGui::SetFocusID
IMGUI_API void SetFocusID(ImGuiID id, ImGuiWindow *window)
Definition: imgui.cpp:2595
ImGuiWindow::DrawList
ImDrawList * DrawList
Definition: imgui_internal.h:1141
ImGuiItemHoveredDataBackup::Restore
void Restore() const
Definition: imgui_internal.h:1190
ImGuiContext::LogClipboard
ImGuiTextBuffer LogClipboard
Definition: imgui_internal.h:868
ImGuiWindow::HiddenFramesForResize
int HiddenFramesForResize
Definition: imgui_internal.h:1120
ImGuiButtonFlags_PressedOnClickRelease
@ ImGuiButtonFlags_PressedOnClickRelease
Definition: imgui_internal.h:279
ImVector::Size
int Size
Definition: imgui.h:1168
ImVec2::x
float x
Definition: imgui.h:166
ImGuiContext::Time
double Time
Definition: imgui_internal.h:728
ImGui::ItemAdd
IMGUI_API bool ItemAdd(const ImRect &bb, ImGuiID id, const ImRect *nav_bb=NULL)
Definition: imgui.cpp:2714
ImGuiTabBar::OffsetMax
float OffsetMax
Definition: imgui_internal.h:1231
ImGuiNavMoveResult::Window
ImGuiWindow * Window
Definition: imgui_internal.h:655
ImGui::TreePushRawID
IMGUI_API void TreePushRawID(ImGuiID id)
Definition: imgui_widgets.cpp:4903
ImGuiStyle
Definition: imgui.h:1224
ImGui::FindWindowSettings
IMGUI_API ImGuiWindowSettings * FindWindowSettings(ImGuiID id)
Definition: imgui.cpp:8809
ImFloorStd
static float ImFloorStd(float x)
Definition: imgui_internal.h:212
ImDrawListSharedData::ClipRectFullscreen
ImVec4 ClipRectFullscreen
Definition: imgui_internal.h:634
ImGuiNextWindowData::SizeVal
ImVec2 SizeVal
Definition: imgui_internal.h:677
ImGui::GetWindowAllowedExtentRect
IMGUI_API ImRect GetWindowAllowedExtentRect(ImGuiWindow *window)
Definition: imgui.cpp:6863
ImGui::PopItemFlag
IMGUI_API void PopItemFlag()
Definition: imgui.cpp:5581
ImRect::Add
void Add(const ImVec2 &p)
Definition: imgui_internal.h:462
ImGuiContext::ActiveIdWindow
ImGuiWindow * ActiveIdWindow
Definition: imgui_internal.h:757
GImGui
IMGUI_API ImGuiContext * GImGui
Definition: imgui.cpp:1042
ImGuiContext::DragDropSourceFlags
ImGuiDragDropFlags DragDropSourceFlags
Definition: imgui_internal.h:823
ImGuiWindow::ScrollbarSizes
ImVec2 ScrollbarSizes
Definition: imgui_internal.h:1100
ImGuiNavMoveResult::ImGuiNavMoveResult
ImGuiNavMoveResult()
Definition: imgui_internal.h:661
ImWchar
unsigned short ImWchar
Definition: imgui.h:119
ImVec1
Definition: imgui_internal.h:268
ImGuiWindow::Active
bool Active
Definition: imgui_internal.h:1102
ImGuiColumnsSet::MaxX
float MaxX
Definition: imgui_internal.h:604
ImGui::LogRenderedText
IMGUI_API void LogRenderedText(const ImVec2 *ref_pos, const char *text, const char *text_end=NULL)
Definition: imgui.cpp:8634
ImGuiWindowTempData::NavLayerCurrentMask
int NavLayerCurrentMask
Definition: imgui_internal.h:1020
ImGuiInputReadMode
ImGuiInputReadMode
Definition: imgui_internal.h:381
ImGuiLayoutType_Vertical
@ ImGuiLayoutType_Vertical
Definition: imgui_internal.h:353
ImGuiContext::NavMousePosDirty
bool NavMousePosDirty
Definition: imgui_internal.h:795
operator-
b2Vec2 operator-(const b2Vec2 &a, const b2Vec2 &b)
Subtract two vectors component-wise.
Definition: b2_math.h:441
ImGuiContext::NavMoveResultLocalVisibleSet
ImGuiNavMoveResult NavMoveResultLocalVisibleSet
Definition: imgui_internal.h:810
ImPool::Remove
void Remove(ImGuiID key, const T *p)
Definition: imgui_internal.h:257
ImGui::UpdateHoveredWindowAndCaptureFlags
IMGUI_API void UpdateHoveredWindowAndCaptureFlags()
Definition: imgui.cpp:3229
ImGuiContext::DragDropWithinSourceOrTarget
bool DragDropWithinSourceOrTarget
Definition: imgui_internal.h:822
ImGuiStorage::GetInt
IMGUI_API int GetInt(ImGuiID key, int default_val=0) const
Definition: imgui.cpp:1861
ImGuiContext::ScrollbarClickDeltaToGrabCenter
ImVec2 ScrollbarClickDeltaToGrabCenter
Definition: imgui_internal.h:851
ImGuiContext::NavInputSource
ImGuiInputSource NavInputSource
Definition: imgui_internal.h:783
ImGuiNextWindowData
Definition: imgui_internal.h:666
ImGui::GetNavInputAmount2d
IMGUI_API ImVec2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor=0.0f, float fast_factor=0.0f)
Definition: imgui.cpp:7371
ImGuiTabBarFlags_IsFocused
@ ImGuiTabBarFlags_IsFocused
Definition: imgui_internal.h:1201
ImGuiNavForward_None
@ ImGuiNavForward_None
Definition: imgui_internal.h:421
ImGuiWindowSettings::Pos
ImVec2 Pos
Definition: imgui_internal.h:555
ImGuiTabBar::ScrollingTarget
float ScrollingTarget
Definition: imgui_internal.h:1234
ImGuiWindowTempData
Definition: imgui_internal.h:1002
ImGuiContext::NavIdIsAlive
bool NavIdIsAlive
Definition: imgui_internal.h:794
ImGui::IsWindowNavFocusable
IMGUI_API bool IsWindowNavFocusable(ImGuiWindow *window)
Definition: imgui.cpp:5877
ImGuiWindow::SizeContentsExplicit
ImVec2 SizeContentsExplicit
Definition: imgui_internal.h:1090
ImGui::GetWindowScrollMaxY
IMGUI_API float GetWindowScrollMaxY(ImGuiWindow *window)
Definition: imgui.cpp:4523
ImGuiContext::DrawData
ImDrawData DrawData
Definition: imgui_internal.h:814
ImGuiContext::WindowsSortBuffer
ImVector< ImGuiWindow * > WindowsSortBuffer
Definition: imgui_internal.h:734
ImGuiWindowTempData::LayoutType
ImGuiLayoutType LayoutType
Definition: imgui_internal.h:1029
ImLinearSweep
static float ImLinearSweep(float current, float target, float speed)
Definition: imgui_internal.h:236
ImRect::Add
void Add(const ImRect &r)
Definition: imgui_internal.h:463
ImGuiInputSource_NavKeyboard
@ ImGuiInputSource_NavKeyboard
Definition: imgui_internal.h:375
IM_ARRAYSIZE
#define IM_ARRAYSIZE(_ARR)
Definition: imgui.h:73
ImGui::SetHoveredID
IMGUI_API void SetHoveredID(ImGuiID id)
Definition: imgui.cpp:2622
ImGuiGroupData::BackupActiveIdIsAlive
ImGuiID BackupActiveIdIsAlive
Definition: imgui_internal.h:502
ImGui::BeginPopupEx
IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags)
Definition: imgui.cpp:6753
ImFontAtlasBuildMultiplyCalcLookupTable
IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor)
Definition: imgui_draw.cpp:1719
ImGuiTabBar::GetTabOrder
int GetTabOrder(const ImGuiTabItem *tab) const
Definition: imgui_internal.h:1243
ImGuiWindowTempData::TreeDepthMayJumpToParentOnPop
ImU32 TreeDepthMayJumpToParentOnPop
Definition: imgui_internal.h:1014
ImGuiColumnsFlags_GrowParentContentsSize
@ ImGuiColumnsFlags_GrowParentContentsSize
Definition: imgui_internal.h:314
ImDrawDataBuilder::Layers
ImVector< ImDrawList * > Layers[2]
Definition: imgui_internal.h:645
ImGuiColumnsFlags
int ImGuiColumnsFlags
Definition: imgui.h:133
ImRect::ImRect
ImRect()
Definition: imgui_internal.h:446
ImGui::ActivateItem
IMGUI_API void ActivateItem(ImGuiID id)
Definition: imgui.cpp:6304
ImVector::reserve
void reserve(int new_capacity)
Definition: imgui.h:1203
ImGuiPopupRef::OpenPopupPos
ImVec2 OpenPopupPos
Definition: imgui_internal.h:582
ImGui::SetNavID
IMGUI_API void SetNavID(ImGuiID id, int nav_layer)
Definition: imgui.cpp:2550
ImGui::FindRenderedTextEnd
const IMGUI_API char * FindRenderedTextEnd(const char *text, const char *text_end=NULL)
Definition: imgui.cpp:2211
ImPool::GetIndex
ImPoolIdx GetIndex(const T *p) const
Definition: imgui_internal.h:253
ImRect
Definition: imgui_internal.h:441
ImGuiButtonFlags_AllowItemOverlap
@ ImGuiButtonFlags_AllowItemOverlap
Definition: imgui_internal.h:284
ImGuiContext::DragDropAcceptIdCurr
ImGuiID DragDropAcceptIdCurr
Definition: imgui_internal.h:831
ImGuiContext::FrameScopeActive
bool FrameScopeActive
Definition: imgui_internal.h:718
ImGui::GetFrontMostPopupModal
IMGUI_API ImGuiWindow * GetFrontMostPopupModal()
Definition: imgui.cpp:6600
ImGui::SetActiveID
IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow *window)
Definition: imgui.cpp:2569
ImGuiContext::ColorEditOptions
ImGuiColorEditFlags ColorEditOptions
Definition: imgui_internal.h:846
ImGuiWindowSettings::Collapsed
bool Collapsed
Definition: imgui_internal.h:557
ImGuiNavHighlightFlags_None
@ ImGuiNavHighlightFlags_None
Definition: imgui_internal.h:393
d
d
ImGuiTabItem::LastFrameSelected
int LastFrameSelected
Definition: imgui_internal.h:1211
ImGuiSettingsHandler
Definition: imgui_internal.h:562
ImFontConfig
Definition: imgui.h:1901
ImGui::IsKeyPressedMap
bool IsKeyPressedMap(ImGuiKey key, bool repeat=true)
Definition: imgui_internal.h:1347
ImGui::TabBarCloseTab
IMGUI_API void TabBarCloseTab(ImGuiTabBar *tab_bar, ImGuiTabItem *tab)
Definition: imgui_widgets.cpp:6109
ImGuiContext::CurrentTabBar
ImVector< ImGuiTabBar * > CurrentTabBar
Definition: imgui_internal.h:839
ImAtof
static double ImAtof(const char *s)
Definition: imgui_internal.h:211
ImGuiItemStatusFlags_HoveredRect
@ ImGuiItemStatusFlags_HoveredRect
Definition: imgui_internal.h:337
ImGuiContext::NavActivatePressedId
ImGuiID NavActivatePressedId
Definition: imgui_internal.h:778
ImGuiNavForward_ForwardQueued
@ ImGuiNavForward_ForwardQueued
Definition: imgui_internal.h:422
ImGuiContext::HoveredIdAllowOverlap
bool HoveredIdAllowOverlap
Definition: imgui_internal.h:742
ImRect::GetWidth
float GetWidth() const
Definition: imgui_internal.h:453
ImGui::TreeNodeBehaviorIsOpen
IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags=0)
Definition: imgui_widgets.cpp:4693
ImPool::GetSize
int GetSize() const
Definition: imgui_internal.h:260
ImGuiPopupRef::OpenParentId
ImGuiID OpenParentId
Definition: imgui_internal.h:581
ImGui::ShadeVertsLinearUV
IMGUI_API void ShadeVertsLinearUV(ImDrawList *draw_list, int vert_start_idx, int vert_end_idx, const ImVec2 &a, const ImVec2 &b, const ImVec2 &uv_a, const ImVec2 &uv_b, bool clamp)
Definition: imgui_draw.cpp:1319
ImGuiContext::SettingsLoaded
bool SettingsLoaded
Definition: imgui_internal.h:859
ImPool::FreeIdx
ImPoolIdx FreeIdx
Definition: imgui_internal.h:247
ImGuiWindow::AutoFitChildAxises
int AutoFitChildAxises
Definition: imgui_internal.h:1117
ImGui::StartMouseMovingWindow
IMGUI_API void StartMouseMovingWindow(ImGuiWindow *window)
Definition: imgui.cpp:3020
ImVec4::x
float x
Definition: imgui.h:178
ImGui::SetNavIDWithRectRel
IMGUI_API void SetNavIDWithRectRel(ImGuiID id, int nav_layer, const ImRect &rect_rel)
Definition: imgui.cpp:2559
ImGuiInputReadMode_Pressed
@ ImGuiInputReadMode_Pressed
Definition: imgui_internal.h:384
ImGuiNextWindowData::CollapsedVal
bool CollapsedVal
Definition: imgui_internal.h:679
ImGuiSettingsHandler::ReadLineFn
void(* ReadLineFn)(ImGuiContext *ctx, ImGuiSettingsHandler *handler, void *entry, const char *line)
Definition: imgui_internal.h:567
ImGuiWindowSettings::Name
char * Name
Definition: imgui_internal.h:553
ImMax
static T ImMax(T lhs, T rhs)
Definition: imgui_internal.h:217
ImGuiItemHoveredDataBackup::LastItemRect
ImRect LastItemRect
Definition: imgui_internal.h:1185
ImGuiWindow::TitleBarRect
ImRect TitleBarRect() const
Definition: imgui_internal.h:1175
ImGuiContext
Definition: imgui_internal.h:715
ImU32
unsigned int ImU32
Definition: imgui.h:150
ImGuiColumnsFlags_None
@ ImGuiColumnsFlags_None
Definition: imgui_internal.h:309
ImGui::InputTextEx
IMGUI_API bool InputTextEx(const char *label, char *buf, int buf_size, const ImVec2 &size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback=NULL, void *user_data=NULL)
Definition: imgui_widgets.cpp:3122
ImGuiColumnsSet::Current
int Current
Definition: imgui_internal.h:602
ImRect::Contains
bool Contains(const ImVec2 &p) const
Definition: imgui_internal.h:459
ImGui::FocusableItemUnregister
IMGUI_API void FocusableItemUnregister(ImGuiWindow *window)
Definition: imgui.cpp:2855
ImGui::CreateNewWindowSettings
IMGUI_API ImGuiWindowSettings * CreateNewWindowSettings(const char *name)
Definition: imgui.cpp:8799
ImGuiWindowTempData::ChildWindows
ImVector< ImGuiWindow * > ChildWindows
Definition: imgui_internal.h:1027
ImGui::RenderRectFilledRangeH
IMGUI_API void RenderRectFilledRangeH(ImDrawList *draw_list, const ImRect &rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding)
Definition: imgui_draw.cpp:2906
ImGuiWindow::ClipRect
ImRect ClipRect
Definition: imgui_internal.h:1129
ImGuiContext::NavMoveResultOther
ImGuiNavMoveResult NavMoveResultOther
Definition: imgui_internal.h:811
ImGuiIO::FontDefault
ImFont * FontDefault
Definition: imgui.h:1293
ImParseFormatTrimDecorations
const IMGUI_API char * ImParseFormatTrimDecorations(const char *format, char *buf, int buf_size)
Definition: imgui_widgets.cpp:2571
ImRect::GetBL
ImVec2 GetBL() const
Definition: imgui_internal.h:457
ImGuiWindow::Pos
ImVec2 Pos
Definition: imgui_internal.h:1085
ImFmod
static float ImFmod(float x, float y)
Definition: imgui_internal.h:205
ImDrawList::_OwnerName
const char * _OwnerName
Definition: imgui.h:1797
ImGuiSeparatorFlags_Horizontal
@ ImGuiSeparatorFlags_Horizontal
Definition: imgui_internal.h:329
ImGuiContext::NavWindowingHighlightAlpha
float NavWindowingHighlightAlpha
Definition: imgui_internal.h:790
ImInvLength
static float ImInvLength(const ImVec2 &lhs, float fail_value)
Definition: imgui_internal.h:231
ImGuiNextWindowData::SizeCallback
ImGuiSizeCallback SizeCallback
Definition: imgui_internal.h:681
ImGuiGroupData
Definition: imgui_internal.h:493
ImGuiContext::Initialized
bool Initialized
Definition: imgui_internal.h:717
ImGui::ClearDragDrop
IMGUI_API void ClearDragDrop()
Definition: imgui.cpp:8317
ImGuiContext::MouseCursor
ImGuiMouseCursor MouseCursor
Definition: imgui_internal.h:818
ImGui::RenderFrameBorder
IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding=0.0f)
Definition: imgui.cpp:2325
ImGui::TabItemLabelAndCloseButton
IMGUI_API bool TabItemLabelAndCloseButton(ImDrawList *draw_list, const ImRect &bb, ImGuiTabItemFlags flags, const char *label, ImGuiID tab_id, ImGuiID close_button_id)
Definition: imgui_widgets.cpp:6482
ImGuiLayoutType
int ImGuiLayoutType
Definition: imgui_internal.h:75
ImGuiInputTextState::TextW
ImVector< ImWchar > TextW
Definition: imgui_internal.h:525
ImFabs
static float ImFabs(float x)
Definition: imgui_internal.h:201
ImGuiWindow::DC
ImGuiWindowTempData DC
Definition: imgui_internal.h:1127
ImGuiColumnsFlags_
ImGuiColumnsFlags_
Definition: imgui_internal.h:306
ImGuiWindow::PopupId
ImGuiID PopupId
Definition: imgui_internal.h:1114
ImGui::ColorEditOptionsPopup
IMGUI_API void ColorEditOptionsPopup(const float *col, ImGuiColorEditFlags flags)
Definition: imgui_widgets.cpp:4506
ImGuiContext::BeginPopupStack
ImVector< ImGuiPopupRef > BeginPopupStack
Definition: imgui_internal.h:768
ImGuiContext::ActiveIdAllowNavDirFlags
int ActiveIdAllowNavDirFlags
Definition: imgui_internal.h:755
ImStrlenW
IMGUI_API int ImStrlenW(const ImWchar *str)
Definition: imgui.cpp:1312
ImDrawDataBuilder
Definition: imgui_internal.h:643
ImPool::Clear
void Clear()
Definition: imgui_internal.h:255
ImGuiAxis
ImGuiAxis
Definition: imgui_internal.h:357
ImGuiPlotType_Lines
@ ImGuiPlotType_Lines
Definition: imgui_internal.h:366
ImGuiWindow
Definition: imgui_internal.h:1080
ImTextCountUtf8BytesFromStr
IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar *in_text, const ImWchar *in_text_end)
Definition: imgui.cpp:1694
ImRect::GetTL
ImVec2 GetTL() const
Definition: imgui_internal.h:455
ImGuiItemStatusFlags_Edited
@ ImGuiItemStatusFlags_Edited
Definition: imgui_internal.h:339
ImGuiItemFlags_NoNav
@ ImGuiItemFlags_NoNav
Definition: imgui_internal.h:994
ImGui::TreeNodeBehavior
IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *label, const char *label_end=NULL)
Definition: imgui_widgets.cpp:4740
ImGuiItemHoveredDataBackup::LastItemId
ImGuiID LastItemId
Definition: imgui_internal.h:1183
ImGuiTabBar::WantLayout
bool WantLayout
Definition: imgui_internal.h:1238
ImGuiColumnData::ClipRect
ImRect ClipRect
Definition: imgui_internal.h:591
ImGuiWindowTempData::MenuBarOffset
ImVec2 MenuBarOffset
Definition: imgui_internal.h:1026
ImGuiContext::NavMoveDirLast
ImGuiDir NavMoveDirLast
Definition: imgui_internal.h:807
ImRect::GetCenter
ImVec2 GetCenter() const
Definition: imgui_internal.h:451
ImGuiSeparatorFlags_
ImGuiSeparatorFlags_
Definition: imgui_internal.h:326
ImGuiItemFlags_
ImGuiItemFlags_
Definition: imgui_internal.h:989
ImGuiWindowSettings::ID
ImGuiID ID
Definition: imgui_internal.h:554
ImGuiColumnsSet::StartMaxPosX
float StartMaxPosX
Definition: imgui_internal.h:607
operator+
b2Vec2 operator+(const b2Vec2 &a, const b2Vec2 &b)
Add two vectors component-wise.
Definition: b2_math.h:435
ImGui::MarkIniSettingsDirty
IMGUI_API void MarkIniSettingsDirty()
Definition: imgui.cpp:8784
ImSwap
static void ImSwap(T &a, T &b)
Definition: imgui_internal.h:220
ImGuiContext::NavMoveRequestForward
ImGuiNavForward NavMoveRequestForward
Definition: imgui_internal.h:806
ImGuiNextWindowData::PosVal
ImVec2 PosVal
Definition: imgui_internal.h:675
ImGui::NavMoveRequestTryWrapping
IMGUI_API void NavMoveRequestTryWrapping(ImGuiWindow *window, ImGuiNavMoveFlags move_flags)
Definition: imgui.cpp:7235
ImGuiContext::NavScoringRectScreen
ImRect NavScoringRectScreen
Definition: imgui_internal.h:784
ImGuiWindow::MenuColumns
ImGuiMenuColumns MenuColumns
Definition: imgui_internal.h:1135
ImStricmp
IMGUI_API int ImStricmp(const char *str1, const char *str2)
Definition: imgui.cpp:1264
ImGui::RenderTextClippedEx
IMGUI_API void RenderTextClippedEx(ImDrawList *draw_list, const ImVec2 &pos_min, const ImVec2 &pos_max, const char *text, const char *text_end, const ImVec2 *text_size_if_known, const ImVec2 &align=ImVec2(0, 0), const ImRect *clip_rect=NULL)
Definition: imgui.cpp:2268
ImGuiTabBarSortItem
Definition: imgui_internal.h:705
ImFontAtlas::Fonts
ImVector< ImFont * > Fonts
Definition: imgui.h:2059
ImGuiWindowSettings::ImGuiWindowSettings
ImGuiWindowSettings()
Definition: imgui_internal.h:559
ImGuiNavMoveResult::DistCenter
float DistCenter
Definition: imgui_internal.h:657
ImGui::RenderFrame
IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border=true, float rounding=0.0f)
Definition: imgui.cpp:2312
ImGui::Indent
IMGUI_API void Indent(float indent_w=0.0f)
Definition: imgui.cpp:6499
ImGui::ColorTooltip
IMGUI_API void ColorTooltip(const char *text, const float *col, ImGuiColorEditFlags flags)
Definition: imgui_widgets.cpp:4482
ImGuiContext::NavInitRequest
bool NavInitRequest
Definition: imgui_internal.h:799
ImGuiNextWindowData::BgAlphaVal
float BgAlphaVal
Definition: imgui_internal.h:683
ImSin
static float ImSin(float x)
Definition: imgui_internal.h:208
ImTriangleContainsPoint
IMGUI_API bool ImTriangleContainsPoint(const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p)
Definition: imgui.cpp:1229
ImGuiNavHighlightFlags_TypeThin
@ ImGuiNavHighlightFlags_TypeThin
Definition: imgui_internal.h:395
ImStrchrRange
const IMGUI_API char * ImStrchrRange(const char *str_begin, const char *str_end, char c)
Definition: imgui.cpp:1306
ImGuiContext::LogStartDepth
int LogStartDepth
Definition: imgui_internal.h:869
ImAtan2
static float ImAtan2(float y, float x)
Definition: imgui_internal.h:210
ImGuiWindow::NameBufLen
int NameBufLen
Definition: imgui_internal.h:1094
ImGuiContext::FramerateSecPerFrame
float FramerateSecPerFrame[120]
Definition: imgui_internal.h:873
ImRect::ImRect
ImRect(const ImVec4 &v)
Definition: imgui_internal.h:448
ImGuiContext::SettingsIniData
ImGuiTextBuffer SettingsIniData
Definition: imgui_internal.h:861
ImGuiTabBar::ReorderRequestTabId
ImGuiID ReorderRequestTabId
Definition: imgui_internal.h:1236
ImGuiMenuColumns::Count
int Count
Definition: imgui_internal.h:510
ImGuiColumnsSet::Clear
void Clear()
Definition: imgui_internal.h:611
ImGuiNavMoveResult::DistBox
float DistBox
Definition: imgui_internal.h:656
ImGui::IsWindowChildOf
IMGUI_API bool IsWindowChildOf(ImGuiWindow *window, ImGuiWindow *potential_parent)
Definition: imgui.cpp:5799
ImGuiWindow::MoveId
ImGuiID MoveId
Definition: imgui_internal.h:1095
ImGuiWindowTempData::CurrentLineTextBaseOffset
float CurrentLineTextBaseOffset
Definition: imgui_internal.h:1009
ImGuiStorage::GetIntRef
IMGUI_API int * GetIntRef(ImGuiID key, int default_val=0)
Definition: imgui.cpp:1891
ImTextCountUtf8BytesFromChar
IMGUI_API int ImTextCountUtf8BytesFromChar(const char *in_text, const char *in_text_end)
Definition: imgui.cpp:1663
ImGuiInputTextState::ImGuiInputTextState
ImGuiInputTextState()
Definition: imgui_internal.h:541
ImGuiInputTextState::ClearSelection
void ClearSelection()
Definition: imgui_internal.h:545
ImPool::Add
T * Add()
Definition: imgui_internal.h:256
ImGuiContext::ColorModifiers
ImVector< ImGuiColorMod > ColorModifiers
Definition: imgui_internal.h:764
ImGuiWindow::WindowBorderSize
float WindowBorderSize
Definition: imgui_internal.h:1093
ImGuiNavHighlightFlags_NoRounding
@ ImGuiNavHighlightFlags_NoRounding
Definition: imgui_internal.h:397
ImGuiWindow::OuterRectClipped
ImRect OuterRectClipped
Definition: imgui_internal.h:1130
ImGui::SetWindowScrollY
IMGUI_API void SetWindowScrollY(ImGuiWindow *window, float new_scroll_y)
Definition: imgui.cpp:5908
ImGuiColorMod::BackupValue
ImVec4 BackupValue
Definition: imgui_internal.h:479
ImGuiItemStatusFlags
int ImGuiItemStatusFlags
Definition: imgui_internal.h:81
ImGuiStyleMod::ImGuiStyleMod
ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v)
Definition: imgui_internal.h:489
ImGuiColumnsSet::StartPosY
float StartPosY
Definition: imgui_internal.h:606
ImGuiWindowTempData::MenuBarAppending
bool MenuBarAppending
Definition: imgui_internal.h:1025
ImGuiWindow::CalcFontSize
float CalcFontSize() const
Definition: imgui_internal.h:1173
ImGui::NavMoveRequestButNoResultYet
IMGUI_API bool NavMoveRequestButNoResultYet()
Definition: imgui.cpp:7210
ImGuiNavDirSourceFlags
int ImGuiNavDirSourceFlags
Definition: imgui_internal.h:83
IM_PLACEMENT_NEW
#define IM_PLACEMENT_NEW(_PTR)
Definition: imgui.h:1523
ImGuiNextWindowData::SizeCallbackUserData
void * SizeCallbackUserData
Definition: imgui_internal.h:682
ImGuiMenuColumns::Spacing
float Spacing
Definition: imgui_internal.h:511
ImFontAtlasBuildFinish
IMGUI_API void ImFontAtlasBuildFinish(ImFontAtlas *atlas)
Definition: imgui_draw.cpp:2036
ImGuiNavHighlightFlags_TypeDefault
@ ImGuiNavHighlightFlags_TypeDefault
Definition: imgui_internal.h:394
ImGui::BeginTooltipEx
IMGUI_API void BeginTooltipEx(ImGuiWindowFlags extra_flags, bool override_previous_tooltip=true)
Definition: imgui.cpp:6541
ImGuiInputReadMode_Released
@ ImGuiInputReadMode_Released
Definition: imgui_internal.h:385
ImGuiContext::DragDropTargetId
ImGuiID DragDropTargetId
Definition: imgui_internal.h:828
ImGui::NavMoveRequestForward
IMGUI_API void NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect &bb_rel, ImGuiNavMoveFlags move_flags)
Definition: imgui.cpp:7223
ImLerp
static T ImLerp(T a, T b, float t)
Definition: imgui_internal.h:219
ImGui::EndColumns
IMGUI_API void EndColumns()
Definition: imgui.cpp:8228
ImGuiDragFlags_None
@ ImGuiDragFlags_None
Definition: imgui_internal.h:302
ImFileOpen
IMGUI_API FILE * ImFileOpen(const char *filename, const char *file_open_mode)
Definition: imgui.cpp:1467
ImRect::GetHeight
float GetHeight() const
Definition: imgui_internal.h:454
ImGuiStorage::SetInt
IMGUI_API void SetInt(ImGuiID key, int val)
Definition: imgui.cpp:1921
ImGui::IsNavInputDown
bool IsNavInputDown(ImGuiNavInput n)
Definition: imgui_internal.h:1348
ImGui::PushMultiItemsWidths
IMGUI_API void PushMultiItemsWidths(int components, float width_full=0.0f)
Definition: imgui.cpp:5503
ImGuiGroupData::BackupIndent
ImVec1 BackupIndent
Definition: imgui_internal.h:497
ImGuiWindow::Size
ImVec2 Size
Definition: imgui_internal.h:1086
ImDrawListSharedData
Definition: imgui_internal.h:628
ImVector::resize
void resize(int new_size)
Definition: imgui.h:1201
ImGui::GetNavInputAmount
IMGUI_API float GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode)
Definition: imgui.cpp:7349
ImPoolIdx
int ImPoolIdx
Definition: imgui_internal.h:241
ImGuiSelectableFlags_NoHoldingActiveID
@ ImGuiSelectableFlags_NoHoldingActiveID
Definition: imgui_internal.h:320
ImGuiContext::NavInitResultId
ImGuiID NavInitResultId
Definition: imgui_internal.h:801
ImFontAtlasBuildPackCustomRects
IMGUI_API void ImFontAtlasBuildPackCustomRects(ImFontAtlas *atlas, void *spc)
Definition: imgui_draw.cpp:1979
ImGuiContext::NavMoveDir
ImGuiDir NavMoveDir
Definition: imgui_internal.h:807
ImGuiDragFlags
int ImGuiDragFlags
Definition: imgui_internal.h:87
ImGuiInputReadMode_RepeatSlow
@ ImGuiInputReadMode_RepeatSlow
Definition: imgui_internal.h:387
ImGui::VerticalSeparator
IMGUI_API void VerticalSeparator()
Definition: imgui_widgets.cpp:1175
ImGuiWindow::SetWindowPosAllowFlags
ImGuiCond SetWindowPosAllowFlags
Definition: imgui_internal.h:1121
ImDrawListSharedData::Font
ImFont * Font
Definition: imgui_internal.h:631
ImStrdupcpy
IMGUI_API char * ImStrdupcpy(char *dst, size_t *p_dst_size, const char *str)
Definition: imgui.cpp:1292
ImGuiWindow::ScrollbarY
bool ScrollbarY
Definition: imgui_internal.h:1101
ImGuiNavHighlightFlags_AlwaysDraw
@ ImGuiNavHighlightFlags_AlwaysDraw
Definition: imgui_internal.h:396
ImGuiWindow::BeginOrderWithinParent
short BeginOrderWithinParent
Definition: imgui_internal.h:1112
ImGuiContext::WindowsFocusOrder
ImVector< ImGuiWindow * > WindowsFocusOrder
Definition: imgui_internal.h:733
ImVec4::w
float w
Definition: imgui.h:178
ImGuiWindow::MenuBarHeight
float MenuBarHeight() const
Definition: imgui_internal.h:1176
ImGuiColumnsSet::IsFirstFrame
bool IsFirstFrame
Definition: imgui_internal.h:600
ImLineClosestPoint
IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2 &a, const ImVec2 &b, const ImVec2 &p)
Definition: imgui.cpp:1216
ImGuiContext::HoveredId
ImGuiID HoveredId
Definition: imgui_internal.h:741
ImGuiContext::NavIdTabCounter
int NavIdTabCounter
Definition: imgui_internal.h:793
ImGuiLayoutType_
ImGuiLayoutType_
Definition: imgui_internal.h:351
ImGuiStyleMod::ImGuiStyleMod
ImGuiStyleMod(ImGuiStyleVar idx, int v)
Definition: imgui_internal.h:487
ImGuiWindow::RootWindowForNav
ImGuiWindow * RootWindowForNav
Definition: imgui_internal.h:1146
ImGuiSliderFlags_Vertical
@ ImGuiSliderFlags_Vertical
Definition: imgui_internal.h:297
ImGuiContext::TempBuffer
char TempBuffer[1024 *3+1]
Definition: imgui_internal.h:879
ImGuiWindow::WantCollapseToggle
bool WantCollapseToggle
Definition: imgui_internal.h:1106
ImGuiContext::DrawDataBuilder
ImDrawDataBuilder DrawDataBuilder
Definition: imgui_internal.h:815
ImGui::Initialize
IMGUI_API void Initialize(ImGuiContext *context)
Definition: imgui.cpp:3473
ImGui::ButtonBehavior
IMGUI_API bool ButtonBehavior(const ImRect &bb, ImGuiID id, bool *out_hovered, bool *out_held, ImGuiButtonFlags flags=0)
Definition: imgui_widgets.cpp:380
ImGuiTabBar::OffsetNextTab
float OffsetNextTab
Definition: imgui_internal.h:1232
ImGui::NavInitWindow
IMGUI_API void NavInitWindow(ImGuiWindow *window, bool force_reinit)
Definition: imgui.cpp:7306
ImGuiStorage
Definition: imgui.h:1597
ImGuiSeparatorFlags_None
@ ImGuiSeparatorFlags_None
Definition: imgui_internal.h:328
ImGuiWindowSettings
Definition: imgui_internal.h:551
ImGuiNavMoveResult::ID
ImGuiID ID
Definition: imgui_internal.h:654
ImGui::IsNavInputPressed
bool IsNavInputPressed(ImGuiNavInput n, ImGuiInputReadMode mode)
Definition: imgui_internal.h:1349
ImGui::RenderPixelEllipsis
IMGUI_API void RenderPixelEllipsis(ImDrawList *draw_list, ImVec2 pos, int count, ImU32 col)
Definition: imgui_draw.cpp:2968
ImFileLoadToMemory
IMGUI_API void * ImFileLoadToMemory(const char *filename, const char *file_open_mode, size_t *out_file_size=NULL, int padding_bytes=0)
Definition: imgui.cpp:1485
ImGuiNextWindowData::SizeCond
ImGuiCond SizeCond
Definition: imgui_internal.h:669
ImStreolRange
const IMGUI_API char * ImStreolRange(const char *str, const char *str_end)
Definition: imgui.cpp:1321
ImGuiItemFlags_ButtonRepeat
@ ImGuiItemFlags_ButtonRepeat
Definition: imgui_internal.h:992
ImGuiContext::NavMoveFromClampedRefRect
bool NavMoveFromClampedRefRect
Definition: imgui_internal.h:803
ImGuiWindow::IDStack
ImVector< ImGuiID > IDStack
Definition: imgui_internal.h:1128
ImGuiInputTextState::SelectedAllMouseLock
bool SelectedAllMouseLock
Definition: imgui_internal.h:534
ImGuiWindow::Name
char * Name
Definition: imgui_internal.h:1082
ImGuiWindow::FocusIdxTabCounter
int FocusIdxTabCounter
Definition: imgui_internal.h:1155
ImGui::ItemSize
IMGUI_API void ItemSize(const ImVec2 &size, float text_offset_y=0.0f)
Definition: imgui.cpp:2679
ImGuiContext::DragDropTargetRect
ImRect DragDropTargetRect
Definition: imgui_internal.h:827
ImGui::TabItemBackground
IMGUI_API void TabItemBackground(ImDrawList *draw_list, const ImRect &bb, ImGuiTabItemFlags flags, ImU32 col)
Definition: imgui_widgets.cpp:6461
ImGuiWindow::Rect
ImRect Rect() const
Definition: imgui_internal.h:1172
ImGui::FindBestWindowPosForPopup
IMGUI_API ImVec2 FindBestWindowPosForPopup(ImGuiWindow *window)
Definition: imgui.cpp:6926
ImTextCountCharsFromUtf8
IMGUI_API int ImTextCountCharsFromUtf8(const char *in_text, const char *in_text_end)
Definition: imgui.cpp:1609
ImGuiItemStatusFlags_HasDisplayRect
@ ImGuiItemStatusFlags_HasDisplayRect
Definition: imgui_internal.h:338
ImGuiGroupData::BackupCursorMaxPos
ImVec2 BackupCursorMaxPos
Definition: imgui_internal.h:496
ImGuiContext::ScalarAsInputTextId
ImGuiID ScalarAsInputTextId
Definition: imgui_internal.h:845
ImGui::BringWindowToDisplayBack
IMGUI_API void BringWindowToDisplayBack(ImGuiWindow *window)
Definition: imgui.cpp:5429
ImGuiPopupPositionPolicy_Default
@ ImGuiPopupPositionPolicy_Default
Definition: imgui_internal.h:435
ImGuiWindow::LastFrameActive
int LastFrameActive
Definition: imgui_internal.h:1133
ImGuiColumnData::Flags
ImGuiColumnsFlags Flags
Definition: imgui_internal.h:590
ImGui::TabBarQueueChangeTabOrder
IMGUI_API void TabBarQueueChangeTabOrder(ImGuiTabBar *tab_bar, const ImGuiTabItem *tab, int dir)
Definition: imgui_widgets.cpp:6144
ImGuiContext::WantTextInputNextFrame
int WantTextInputNextFrame
Definition: imgui_internal.h:878
ImGuiIO
Definition: imgui.h:1269
ImFont
Definition: imgui.h:2071
ImGuiColumnData
Definition: imgui_internal.h:586
ImGuiContext::NavLayer
ImGuiNavLayer NavLayer
Definition: imgui_internal.h:792
ImGuiButtonFlags_FlattenChildren
@ ImGuiButtonFlags_FlattenChildren
Definition: imgui_internal.h:283
ImGuiItemFlags_NoTabStop
@ ImGuiItemFlags_NoTabStop
Definition: imgui_internal.h:991
ImGuiInputTextFlags
int ImGuiInputTextFlags
Definition: imgui.h:139
ImGuiWindowTempData::Indent
ImVec1 Indent
Definition: imgui_internal.h:1042
ImGuiWindow::RootWindowForTitleBarHighlight
ImGuiWindow * RootWindowForTitleBarHighlight
Definition: imgui_internal.h:1145
ImGuiStyle::FramePadding
ImVec2 FramePadding
Definition: imgui.h:1236
ImGui::SetWindowScrollX
IMGUI_API void SetWindowScrollX(ImGuiWindow *window, float new_scroll_x)
Definition: imgui.cpp:5901
ImCharIsBlankA
static bool ImCharIsBlankA(char c)
Definition: imgui_internal.h:147
ImGui::RenderBullet
IMGUI_API void RenderBullet(ImVec2 pos)
Definition: imgui.cpp:2372
ImGui::FocusWindow
IMGUI_API void FocusWindow(ImGuiWindow *window)
Definition: imgui.cpp:5444
ImGui::SliderBehavior
IMGUI_API bool SliderBehavior(const ImRect &bb, ImGuiID id, ImGuiDataType data_type, void *v, const void *v_min, const void *v_max, const char *format, float power, ImGuiSliderFlags flags, ImRect *out_grab_bb)
Definition: imgui_widgets.cpp:2258
ImGuiSettingsHandler::TypeName
const char * TypeName
Definition: imgui_internal.h:564
ImGuiTabBar::CurrFrameVisible
int CurrFrameVisible
Definition: imgui_internal.h:1227
ImGuiButtonFlags_
ImGuiButtonFlags_
Definition: imgui_internal.h:275
ImGuiContext::NavWindowingToggleLayer
bool NavWindowingToggleLayer
Definition: imgui_internal.h:791
ImVec4
Definition: imgui.h:176
ImGuiContext::LastValidMousePos
ImVec2 LastValidMousePos
Definition: imgui_internal.h:762
ImGuiGroupData::BackupActiveIdPreviousFrameIsAlive
bool BackupActiveIdPreviousFrameIsAlive
Definition: imgui_internal.h:503
ImGuiContext::OpenPopupStack
ImVector< ImGuiPopupRef > OpenPopupStack
Definition: imgui_internal.h:767
ImGui::RoundScalarWithFormatT
IMGUI_API T RoundScalarWithFormatT(const char *format, ImGuiDataType data_type, T v)
ImGui::RenderTextWrapped
IMGUI_API void RenderTextWrapped(ImVec2 pos, const char *text, const char *text_end, float wrap_width)
Definition: imgui.cpp:2250
ImGuiContext::NavJustTabbedId
ImGuiID NavJustTabbedId
Definition: imgui_internal.h:780
IM_ASSERT
#define IM_ASSERT(_EXPR)
Definition: imgui.h:64
ImGuiContext::ColorPickerRef
ImVec4 ColorPickerRef
Definition: imgui_internal.h:847
IMGUI_API
#define IMGUI_API
Definition: imgui.h:55
ImGuiWindowTempData::CursorPosPrevLine
ImVec2 CursorPosPrevLine
Definition: imgui_internal.h:1005
ImGuiColumnsFlags_NoPreserveWidths
@ ImGuiColumnsFlags_NoPreserveWidths
Definition: imgui_internal.h:312
ImGuiContext::FontAtlasOwnedByContext
bool FontAtlasOwnedByContext
Definition: imgui_internal.h:720
ImGuiButtonFlags_NoHoldingActiveID
@ ImGuiButtonFlags_NoHoldingActiveID
Definition: imgui_internal.h:289
ImGuiGroupData::BackupGroupOffset
ImVec1 BackupGroupOffset
Definition: imgui_internal.h:498
ImGuiContext::ActiveIdTimer
float ActiveIdTimer
Definition: imgui_internal.h:749
ImGuiWindow::DrawListInst
ImDrawList DrawListInst
Definition: imgui_internal.h:1142
args
ImGuiContext::LogEnabled
bool LogEnabled
Definition: imgui_internal.h:866
ImGuiContext::ActiveIdClickOffset
ImVec2 ActiveIdClickOffset
Definition: imgui_internal.h:756
ImGuiPlotType
ImGuiPlotType
Definition: imgui_internal.h:364
ImGuiContext::FramerateSecPerFrameAccum
float FramerateSecPerFrameAccum
Definition: imgui_internal.h:875
ImGuiWindowFlags_NoTitleBar
@ ImGuiWindowFlags_NoTitleBar
Definition: imgui.h:686
ImGuiTabItem::LastFrameVisible
int LastFrameVisible
Definition: imgui_internal.h:1210
ImGui::BeginTabBarEx
IMGUI_API bool BeginTabBarEx(ImGuiTabBar *tab_bar, const ImRect &bb, ImGuiTabBarFlags flags)
Definition: imgui_widgets.cpp:5839
ImGuiInputTextState::UserFlags
ImGuiInputTextFlags UserFlags
Definition: imgui_internal.h:537
ImGuiTabBarFlagsPrivate_
ImGuiTabBarFlagsPrivate_
Definition: imgui_internal.h:1197
ImGuiColorMod
Definition: imgui_internal.h:476
ImPool::Reserve
void Reserve(int capacity)
Definition: imgui_internal.h:259
ImGuiPopupRef::ParentWindow
ImGuiWindow * ParentWindow
Definition: imgui_internal.h:579
ImGui::SliderCalcRatioFromValueT
IMGUI_API float SliderCalcRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, float power, float linear_zero_pos)
ImGui
Definition: imgui.cpp:1009
ImGuiWindowTempData::LastItemId
ImGuiID LastItemId
Definition: imgui_internal.h:1015
ImGui::FindSettingsHandler
IMGUI_API ImGuiSettingsHandler * FindSettingsHandler(const char *type_name)
Definition: imgui.cpp:8828
ImGuiWindow::Hidden
bool Hidden
Definition: imgui_internal.h:1109
ImTextCharFromUtf8
IMGUI_API int ImTextCharFromUtf8(unsigned int *out_char, const char *in_text, const char *in_text_end)
Definition: imgui.cpp:1532
ImGuiWindowTempData::ItemWidthStack
ImVector< float > ItemWidthStack
Definition: imgui_internal.h:1037
ImGuiTabItem::Flags
ImGuiTabItemFlags Flags
Definition: imgui_internal.h:1209
ImGui::ClosePopupsOverWindow
IMGUI_API void ClosePopupsOverWindow(ImGuiWindow *ref_window)
Definition: imgui.cpp:6675
ImGuiWindow::ChildId
ImGuiID ChildId
Definition: imgui_internal.h:1096
ImGui::GetFocusID
ImGuiID GetFocusID()
Definition: imgui_internal.h:1299
ImGui::Scrollbar
IMGUI_API void Scrollbar(ImGuiLayoutType direction)
Definition: imgui_widgets.cpp:707
ImGuiLayoutType_Horizontal
@ ImGuiLayoutType_Horizontal
Definition: imgui_internal.h:354
ImGui::IsNavInputPressedAnyOfTwo
bool IsNavInputPressedAnyOfTwo(ImGuiNavInput n1, ImGuiNavInput n2, ImGuiInputReadMode mode)
Definition: imgui_internal.h:1350
ImVec1::ImVec1
ImVec1()
Definition: imgui_internal.h:271
ImGuiButtonFlags_None
@ ImGuiButtonFlags_None
Definition: imgui_internal.h:277
ImGuiContext::ActiveIdIsAlive
ImGuiID ActiveIdIsAlive
Definition: imgui_internal.h:748
ImRect::ClipWith
void ClipWith(const ImRect &r)
Definition: imgui_internal.h:469
ImGuiContext::CurrentWindow
ImGuiWindow * CurrentWindow
Definition: imgui_internal.h:738
ImGuiTabBarSortItem::Index
int Index
Definition: imgui_internal.h:707
ImGuiWindowTempData::ParentLayoutType
ImGuiLayoutType ParentLayoutType
Definition: imgui_internal.h:1030
ImGuiContext::DragDropAcceptFrameCount
int DragDropAcceptFrameCount
Definition: imgui_internal.h:833
ImGuiTabBarFlags_DockNodeIsDockSpace
@ ImGuiTabBarFlags_DockNodeIsDockSpace
Definition: imgui_internal.h:1200
ImGuiWindow::ContentsRegionRect
ImRect ContentsRegionRect
Definition: imgui_internal.h:1132
ImFontAtlasBuildMultiplyRectAlpha8
IMGUI_API void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char *pixels, int x, int y, int w, int h, int stride)
Definition: imgui_draw.cpp:1728
ImGuiTabBar::BarRect
ImRect BarRect
Definition: imgui_internal.h:1229
ImGuiStyleMod
Definition: imgui_internal.h:483
ImGuiContext::ImGuiContext
ImGuiContext(ImFontAtlas *shared_font_atlas)
Definition: imgui_internal.h:881
ImGuiWindow::StateStorage
ImGuiStorage StateStorage
Definition: imgui_internal.h:1136
ImGui::OpenPopupEx
IMGUI_API void OpenPopupEx(ImGuiID id)
Definition: imgui.cpp:6620
ImGuiContext::DragCurrentAccumDirty
bool DragCurrentAccumDirty
Definition: imgui_internal.h:848
ImGuiMouseCursor
int ImGuiMouseCursor
Definition: imgui.h:126
ImGuiItemStatusFlags_
ImGuiItemStatusFlags_
Definition: imgui_internal.h:334
ImGuiDragFlags_Vertical
@ ImGuiDragFlags_Vertical
Definition: imgui_internal.h:303
ImLengthSqr
static float ImLengthSqr(const ImVec2 &lhs)
Definition: imgui_internal.h:229
ImGuiTabBar::VisibleTabId
ImGuiID VisibleTabId
Definition: imgui_internal.h:1226
ImGuiSizeCallback
void(* ImGuiSizeCallback)(ImGuiSizeCallbackData *data)
Definition: imgui.h:146
ImGuiContext::DrawListSharedData
ImDrawListSharedData DrawListSharedData
Definition: imgui_internal.h:726
ImDrawDataBuilder::ClearFreeMemory
void ClearFreeMemory()
Definition: imgui_internal.h:648
ImGui::TabItemEx
IMGUI_API bool TabItemEx(ImGuiTabBar *tab_bar, const char *label, bool *p_open, ImGuiTabItemFlags flags)
Definition: imgui_widgets.cpp:6252
ImGuiTabItemFlags
int ImGuiTabItemFlags
Definition: imgui.h:142
ImGuiTabItem
Definition: imgui_internal.h:1206
ImStristr
const IMGUI_API char * ImStristr(const char *haystack, const char *haystack_end, const char *needle, const char *needle_end)
Definition: imgui.cpp:1334
ImGuiGroupData::BackupCursorPos
ImVec2 BackupCursorPos
Definition: imgui_internal.h:495
ImGuiSelectableFlags_DrawFillAvailWidth
@ ImGuiSelectableFlags_DrawFillAvailWidth
Definition: imgui_internal.h:323
ImGuiWindow::InnerMainRect
ImRect InnerMainRect
Definition: imgui_internal.h:1131
ImGuiContext::StyleModifiers
ImVector< ImGuiStyleMod > StyleModifiers
Definition: imgui_internal.h:765
ImGuiInputTextState::TempBuffer
ImVector< char > TempBuffer
Definition: imgui_internal.h:527
ImFontAtlasBuildWithStbTruetype
IMGUI_API bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas *atlas)
Definition: imgui_draw.cpp:1736
ImGui::GetCurrentWindowRead
ImGuiWindow * GetCurrentWindowRead()
Definition: imgui_internal.h:1257
ImGuiWindow::NavLastChildNavWindow
ImGuiWindow * NavLastChildNavWindow
Definition: imgui_internal.h:1148
ImGuiContext::DragDropSourceFrameCount
int DragDropSourceFrameCount
Definition: imgui_internal.h:824
ImGuiInputReadMode_Down
@ ImGuiInputReadMode_Down
Definition: imgui_internal.h:383
ImGuiSelectableFlags_PressedOnRelease
@ ImGuiSelectableFlags_PressedOnRelease
Definition: imgui_internal.h:322
ImGui::Shutdown
IMGUI_API void Shutdown(ImGuiContext *context)
Definition: imgui.cpp:3491
ImGuiContext::ActiveIdPreviousFrameIsAlive
bool ActiveIdPreviousFrameIsAlive
Definition: imgui_internal.h:753
ImGuiSettingsHandler::WriteAllFn
void(* WriteAllFn)(ImGuiContext *ctx, ImGuiSettingsHandler *handler, ImGuiTextBuffer *out_buf)
Definition: imgui_internal.h:568
ImGuiMouseCursor_Arrow
@ ImGuiMouseCursor_Arrow
Definition: imgui.h:1124
ImGuiStyleVar
int ImGuiStyleVar
Definition: imgui.h:127
ImGuiContext::HoveredWindow
ImGuiWindow * HoveredWindow
Definition: imgui_internal.h:739
ImGuiNextWindowData::Clear
void Clear()
Definition: imgui_internal.h:699
ImRect::GetTR
ImVec2 GetTR() const
Definition: imgui_internal.h:456
ImGuiGroupData::BackupCurrentLineSize
ImVec2 BackupCurrentLineSize
Definition: imgui_internal.h:499
ImGetDirQuadrantFromDelta
IMGUI_API ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy)
Definition: imgui.cpp:6979
ImGui::BringWindowToFocusFront
IMGUI_API void BringWindowToFocusFront(ImGuiWindow *window)
Definition: imgui.cpp:5400
ImGuiItemHoveredDataBackup::LastItemStatusFlags
ImGuiItemStatusFlags LastItemStatusFlags
Definition: imgui_internal.h:1184
t
geometry_msgs::TransformStamped t
ImGuiTabBar::ScrollingAnim
float ScrollingAnim
Definition: imgui_internal.h:1233
ImGuiWindow::ScrollTargetCenterRatio
ImVec2 ScrollTargetCenterRatio
Definition: imgui_internal.h:1099
ImGuiNavMoveFlags_
ImGuiNavMoveFlags_
Definition: imgui_internal.h:408
ImGui::UpdateMouseMovingWindowEndFrame
IMGUI_API void UpdateMouseMovingWindowEndFrame()
Definition: imgui.cpp:3075
ImGuiWindowTempData::ItemWidth
float ItemWidth
Definition: imgui_internal.h:1034
ImGuiButtonFlags_DontClosePopups
@ ImGuiButtonFlags_DontClosePopups
Definition: imgui_internal.h:285
ImGuiWindow::AutoPosLastDirection
ImGuiDir AutoPosLastDirection
Definition: imgui_internal.h:1118
ImGuiContext::TabSortByWidthBuffer
ImVector< ImGuiTabBarSortItem > TabSortByWidthBuffer
Definition: imgui_internal.h:840
ImGuiSettingsHandler::ImGuiSettingsHandler
ImGuiSettingsHandler()
Definition: imgui_internal.h:571
ImGuiWindow::Appearing
bool Appearing
Definition: imgui_internal.h:1108
ImStrTrimBlanks
IMGUI_API void ImStrTrimBlanks(char *str)
Definition: imgui.cpp:1357
ImGuiNavMoveResult::DistAxial
float DistAxial
Definition: imgui_internal.h:658
operator/
TFSIMD_FORCE_INLINE Vector3 operator/(const Vector3 &v, const tfScalar &s)
ImGuiWindow::WriteAccessed
bool WriteAccessed
Definition: imgui_internal.h:1104
ImGuiContext::LogFile
FILE * LogFile
Definition: imgui_internal.h:867
ImGuiContext::DragDropMouseButton
int DragDropMouseButton
Definition: imgui_internal.h:825
ImGui::KeepAliveID
IMGUI_API void KeepAliveID(ImGuiID id)
Definition: imgui.cpp:2637
ImGuiColumnsSet
Definition: imgui_internal.h:596
ImGuiContext::DragDropPayloadBufLocal
unsigned char DragDropPayloadBufLocal[8]
Definition: imgui_internal.h:835
ImGuiContext::NavInputId
ImGuiID NavInputId
Definition: imgui_internal.h:779
ImGuiTabItem::ID
ImGuiID ID
Definition: imgui_internal.h:1208
ImGuiItemFlags_Default_
@ ImGuiItemFlags_Default_
Definition: imgui_internal.h:997
ImGuiWindowTempData::ItemFlagsStack
ImVector< ImGuiItemFlags > ItemFlagsStack
Definition: imgui_internal.h:1036
ImGuiWindow::ScrollTarget
ImVec2 ScrollTarget
Definition: imgui_internal.h:1098
ImGuiButtonFlags_PressedOnDoubleClick
@ ImGuiButtonFlags_PressedOnDoubleClick
Definition: imgui_internal.h:282
ImVec2::y
float y
Definition: imgui.h:166
ImGui::TabBarRemoveTab
IMGUI_API void TabBarRemoveTab(ImGuiTabBar *tab_bar, ImGuiID tab_id)
Definition: imgui_widgets.cpp:6099
ImGuiItemFlags_SelectableDontClosePopup
@ ImGuiItemFlags_SelectableDontClosePopup
Definition: imgui_internal.h:996
ImFontAtlasBuildSetupFont
IMGUI_API void ImFontAtlasBuildSetupFont(ImFontAtlas *atlas, ImFont *font, ImFontConfig *font_config, float ascent, float descent)
Definition: imgui_draw.cpp:1965
ImGuiContext::NavActivateId
ImGuiID NavActivateId
Definition: imgui_internal.h:776
ImGui::FocusableItemRegister
IMGUI_API bool FocusableItemRegister(ImGuiWindow *window, ImGuiID id, bool tab_stop=true)
Definition: imgui.cpp:2830
ImMul
static ImVec2 ImMul(const ImVec2 &lhs, const ImVec2 &rhs)
Definition: imgui_internal.h:237
ImGuiSeparatorFlags_Vertical
@ ImGuiSeparatorFlags_Vertical
Definition: imgui_internal.h:330
ImGuiWindow::BeginOrderWithinContext
short BeginOrderWithinContext
Definition: imgui_internal.h:1113
ImTextStrFromUtf8
IMGUI_API int ImTextStrFromUtf8(ImWchar *buf, int buf_size, const char *in_text, const char *in_text_end, const char **in_remaining=NULL)
Definition: imgui.cpp:1590
ImGuiItemHoveredDataBackup::Backup
void Backup()
Definition: imgui_internal.h:1189
ImGuiWindow::ColumnsStorage
ImVector< ImGuiColumnsSet > ColumnsStorage
Definition: imgui_internal.h:1137
ImGuiContext::DragCurrentAccum
float DragCurrentAccum
Definition: imgui_internal.h:849
ImGuiWindowTempData::LastItemRect
ImRect LastItemRect
Definition: imgui_internal.h:1017
ImGuiContext::MovingWindow
ImGuiWindow * MovingWindow
Definition: imgui_internal.h:763
ImGui::CloseButton
IMGUI_API bool CloseButton(ImGuiID id, const ImVec2 &pos, float radius)
Definition: imgui_widgets.cpp:651
ImGuiPopupRef::PopupId
ImGuiID PopupId
Definition: imgui_internal.h:577

mvsim
Author(s):
autogenerated on Wed May 28 2025 02:13:07