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
ImGuiNavHighlightFlags_TypeDefault
Definition: imgui_internal.h:394
ImPool::Map
ImGuiStorage Map
Definition: imgui_internal.h:246
ImGuiIO::NavInputs
float NavInputs[ImGuiNavInput_COUNT]
Definition: imgui.h:1350
d
d
ImGuiWindow::DC
ImGuiWindowTempData DC
Definition: imgui_internal.h:1127
ImGuiContext::NavMoveDirLast
ImGuiDir NavMoveDirLast
Definition: imgui_internal.h:807
ImGuiButtonFlags_PressedOnDoubleClick
Definition: imgui_internal.h:282
ImGuiItemFlags_Disabled
Definition: imgui_internal.h:993
ImGuiInputTextState::UserFlags
ImGuiInputTextFlags UserFlags
Definition: imgui_internal.h:537
operator/
VectorAcc operator/(const VectorAcc &r1, double r2)
ImGui::NavMoveRequestTryWrapping
IMGUI_API void NavMoveRequestTryWrapping(ImGuiWindow *window, ImGuiNavMoveFlags move_flags)
Definition: imgui.cpp:7235
ImGuiWindow::MenuBarRect
ImRect MenuBarRect() const
Definition: imgui_internal.h:1177
ImAcos
static float ImAcos(float x)
Definition: imgui_internal.h:209
ImGuiGroupData::BackupCursorPos
ImVec2 BackupCursorPos
Definition: imgui_internal.h:495
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)
ImGuiTabBarFlagsPrivate_
ImGuiTabBarFlagsPrivate_
Definition: imgui_internal.h:1197
ImAtan2
static float ImAtan2(float y, float x)
Definition: imgui_internal.h:210
ImPool::GetSize
int GetSize() const
Definition: imgui_internal.h:260
ImStreolRange
IMGUI_API const char * ImStreolRange(const char *str, const char *str_end)
Definition: imgui.cpp:1321
ImGuiWindow::FocusIdxTabRequestNext
int FocusIdxTabRequestNext
Definition: imgui_internal.h:1159
ImGuiWindow::RootWindowForTitleBarHighlight
ImGuiWindow * RootWindowForTitleBarHighlight
Definition: imgui_internal.h:1145
ImCharIsBlankW
static bool ImCharIsBlankW(unsigned int c)
Definition: imgui_internal.h:148
ImGui::ClosePopupToLevel
IMGUI_API void ClosePopupToLevel(int remaining, bool apply_focus_to_window_under)
Definition: imgui.cpp:6712
ImU32
unsigned int ImU32
Definition: imgui.h:150
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
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
ImGuiContext::NavInitResultRectRel
ImRect NavInitResultRectRel
Definition: imgui_internal.h:802
ImGuiWindow::WindowBorderSize
float WindowBorderSize
Definition: imgui_internal.h:1093
ImGuiInputSource
ImGuiInputSource
Definition: imgui_internal.h:370
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
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
ImGuiNavHighlightFlags_TypeThin
Definition: imgui_internal.h:395
ImGui::UpdateMouseMovingWindowNewFrame
IMGUI_API void UpdateMouseMovingWindowNewFrame()
Definition: imgui.cpp:3036
ImGui::TabItemCalcSize
IMGUI_API ImVec2 TabItemCalcSize(const char *label, bool has_close_button)
Definition: imgui_widgets.cpp:6449
ImGuiInputTextState::HasSelection
bool HasSelection() const
Definition: imgui_internal.h:544
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
ImGuiSeparatorFlags_
ImGuiSeparatorFlags_
Definition: imgui_internal.h:326
ImGuiContext::ActiveIdAllowNavDirFlags
int ActiveIdAllowNavDirFlags
Definition: imgui_internal.h:755
ImGuiWindow::SetWindowPosAllowFlags
ImGuiCond SetWindowPosAllowFlags
Definition: imgui_internal.h:1121
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)
ImGui::BringWindowToDisplayFront
IMGUI_API void BringWindowToDisplayFront(ImGuiWindow *window)
Definition: imgui.cpp:5414
ImGuiContext::NavMoveResultLocalVisibleSet
ImGuiNavMoveResult NavMoveResultLocalVisibleSet
Definition: imgui_internal.h:810
ImGuiColumnData::Flags
ImGuiColumnsFlags Flags
Definition: imgui_internal.h:590
ImPool::Data
ImVector< T > Data
Definition: imgui_internal.h:245
ImGuiNavDirSourceFlags_Keyboard
Definition: imgui_internal.h:403
ImGuiContext::DragDropSourceFrameCount
int DragDropSourceFrameCount
Definition: imgui_internal.h:824
ImGuiContext::ActiveIdIsJustActivated
bool ActiveIdIsJustActivated
Definition: imgui_internal.h:750
ImGuiTabBar::LastTabItemIdx
short LastTabItemIdx
Definition: imgui_internal.h:1240
ImGui::RenderMouseCursor
IMGUI_API void RenderMouseCursor(ImDrawList *draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor=ImGuiMouseCursor_Arrow)
Definition: imgui_draw.cpp:2859
ImGui::RenderCheckMark
IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col, float sz)
Definition: imgui.cpp:2379
ImGuiWindow::ParentWindow
ImGuiWindow * ParentWindow
Definition: imgui_internal.h:1143
ImGui::PushColumnClipRect
IMGUI_API void PushColumnClipRect(int column_index=-1)
Definition: imgui.cpp:8142
ImGuiNavLayer_Menu
Definition: imgui_internal.h:429
ImGuiInputReadMode_Released
Definition: imgui_internal.h:385
ImGuiContext::ActiveIdClickOffset
ImVec2 ActiveIdClickOffset
Definition: imgui_internal.h:756
ImGui::ColorEditOptionsPopup
IMGUI_API void ColorEditOptionsPopup(const float *col, ImGuiColorEditFlags flags)
Definition: imgui_widgets.cpp:4506
ImGui::IsPopupOpen
IMGUI_API bool IsPopupOpen(ImGuiID id)
Definition: imgui.cpp:6588
ImRect::GetTL
ImVec2 GetTL() const
Definition: imgui_internal.h:455
ImGuiContext::ActiveIdIsAlive
ImGuiID ActiveIdIsAlive
Definition: imgui_internal.h:748
ImRect::GetWidth
float GetWidth() const
Definition: imgui_internal.h:453
ImGui::SliderCalcRatioFromValueT
IMGUI_API float SliderCalcRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, float power, float linear_zero_pos)
ImGuiStyleMod::ImGuiStyleMod
ImGuiStyleMod(ImGuiStyleVar idx, int v)
Definition: imgui_internal.h:487
ImGuiContext::DrawData
ImDrawData DrawData
Definition: imgui_internal.h:814
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
ImGuiColumnsFlags_NoBorder
Definition: imgui_internal.h:310
ImGuiStorage::Clear
void Clear()
Definition: imgui.h:1612
ImGui::ClosePopupsOverWindow
IMGUI_API void ClosePopupsOverWindow(ImGuiWindow *ref_window)
Definition: imgui.cpp:6675
ImGuiAxis_X
Definition: imgui_internal.h:360
ImGui::FindRenderedTextEnd
IMGUI_API const char * FindRenderedTextEnd(const char *text, const char *text_end=NULL)
Definition: imgui.cpp:2211
ImGuiContext::WantCaptureMouseNextFrame
int WantCaptureMouseNextFrame
Definition: imgui_internal.h:876
ImRect::GetHeight
float GetHeight() const
Definition: imgui_internal.h:454
ImGui::FindWindowSettings
IMGUI_API ImGuiWindowSettings * FindWindowSettings(ImGuiID id)
Definition: imgui.cpp:8809
IM_FMTLIST
#define IM_FMTLIST(FMT)
Definition: imgui.h:71
ImGui::IsWindowChildOf
IMGUI_API bool IsWindowChildOf(ImGuiWindow *window, ImGuiWindow *potential_parent)
Definition: imgui.cpp:5799
ImGuiButtonFlags_NoHoldingActiveID
Definition: imgui_internal.h:289
ImGui::ArrowButtonEx
IMGUI_API bool ArrowButtonEx(const char *str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags)
Definition: imgui_widgets.cpp:615
ImGui::PopItemFlag
IMGUI_API void PopItemFlag()
Definition: imgui.cpp:5581
ImRect::TranslateX
void TranslateX(float dx)
Definition: imgui_internal.h:467
f
f
ImGuiInputTextCallback
int(* ImGuiInputTextCallback)(ImGuiInputTextCallbackData *data)
Definition: imgui.h:145
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
ImGui::GetItemID
ImGuiID GetItemID()
Definition: imgui_internal.h:1297
ImGuiContext::NavActivateId
ImGuiID NavActivateId
Definition: imgui_internal.h:776
ImGui::LogRenderedText
IMGUI_API void LogRenderedText(const ImVec2 *ref_pos, const char *text, const char *text_end=NULL)
Definition: imgui.cpp:8634
ImGuiSliderFlags_Vertical
Definition: imgui_internal.h:297
ImGuiTabBar::VisibleTabWasSubmitted
bool VisibleTabWasSubmitted
Definition: imgui_internal.h:1239
ImGuiContext::TabSortByWidthBuffer
ImVector< ImGuiTabBarSortItem > TabSortByWidthBuffer
Definition: imgui_internal.h:840
ImGuiWindow::FontWindowScale
float FontWindowScale
Definition: imgui_internal.h:1138
ImPool::GetByIndex
T * GetByIndex(ImPoolIdx n)
Definition: imgui_internal.h:252
ImGuiTabBar::NextSelectedTabId
ImGuiID NextSelectedTabId
Definition: imgui_internal.h:1225
ImGuiNavHighlightFlags_
ImGuiNavHighlightFlags_
Definition: imgui_internal.h:391
ImGuiStb::STB_TexteditState
Definition: imgui_internal.h:318
ImVec2
Definition: imgui.h:164
ImGui::IsKeyPressed
IMGUI_API bool IsKeyPressed(int user_key_index, bool repeat=true)
Definition: imgui.cpp:3989
ImGuiTabBar::ScrollingTarget
float ScrollingTarget
Definition: imgui_internal.h:1234
ImGuiContext::ImGuiContext
ImGuiContext(ImFontAtlas *shared_font_atlas)
Definition: imgui_internal.h:881
ImRect::GetBL
ImVec2 GetBL() const
Definition: imgui_internal.h:457
ImGuiWindowTempData::ItemWidthStack
ImVector< float > ItemWidthStack
Definition: imgui_internal.h:1037
ImGuiContext::TooltipOverrideCount
int TooltipOverrideCount
Definition: imgui_internal.h:852
ImGui::PushMultiItemsWidths
IMGUI_API void PushMultiItemsWidths(int components, float width_full=0.0f)
Definition: imgui.cpp:5503
ImStrdupcpy
IMGUI_API char * ImStrdupcpy(char *dst, size_t *p_dst_size, const char *str)
Definition: imgui.cpp:1292
ImGui::RenderFrameBorder
IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding=0.0f)
Definition: imgui.cpp:2325
ImGuiContext::ActiveIdAllowOverlap
bool ActiveIdAllowOverlap
Definition: imgui_internal.h:751
ImGuiContext::ScrollbarClickDeltaToGrabCenter
ImVec2 ScrollbarClickDeltaToGrabCenter
Definition: imgui_internal.h:851
ImGuiInputSource_COUNT
Definition: imgui_internal.h:377
ImGuiNavMoveFlags_AlsoScoreVisibleSet
Definition: imgui_internal.h:416
ImGuiColumnsFlags_NoResize
Definition: imgui_internal.h:311
ImGuiNavMoveResult::Window
ImGuiWindow * Window
Definition: imgui_internal.h:655
ImGuiContext::FramerateSecPerFrameIdx
int FramerateSecPerFrameIdx
Definition: imgui_internal.h:874
ImGuiTabBarFlags_DockNodeIsDockSpace
Definition: imgui_internal.h:1200
ImGuiTabBarFlags_DockNode
Definition: imgui_internal.h:1199
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
ImGuiNavDirSourceFlags_PadLStick
Definition: imgui_internal.h:405
ImGuiPopupPositionPolicy_Default
Definition: imgui_internal.h:435
ImGui::FindWindowByID
IMGUI_API ImGuiWindow * FindWindowByID(ImGuiID id)
Definition: imgui.cpp:4381
ImGuiSizeCallback
void(* ImGuiSizeCallback)(ImGuiSizeCallbackData *data)
Definition: imgui.h:146
ImGui::SetHoveredID
IMGUI_API void SetHoveredID(ImGuiID id)
Definition: imgui.cpp:2622
ImGuiContext::HoveredId
ImGuiID HoveredId
Definition: imgui_internal.h:741
IM_FMTARGS
#define IM_FMTARGS(FMT)
Definition: imgui.h:70
ImGuiContext::OverlayDrawList
ImDrawList OverlayDrawList
Definition: imgui_internal.h:817
ImGuiWindow::FocusIdxAllRequestCurrent
int FocusIdxAllRequestCurrent
Definition: imgui_internal.h:1156
ImGuiContext::NavMoveResultLocal
ImGuiNavMoveResult NavMoveResultLocal
Definition: imgui_internal.h:809
ImRect::IsInverted
bool IsInverted() const
Definition: imgui_internal.h:472
ImGuiContext::HoveredIdTimer
float HoveredIdTimer
Definition: imgui_internal.h:744
ImGuiContext::LastValidMousePos
ImVec2 LastValidMousePos
Definition: imgui_internal.h:762
ImGuiTabItem::Flags
ImGuiTabItemFlags Flags
Definition: imgui_internal.h:1209
ImGuiNavLayer_COUNT
Definition: imgui_internal.h:430
ImGuiTreeNodeFlags
int ImGuiTreeNodeFlags
Definition: imgui.h:143
ImClamp
static T ImClamp(T v, T mn, T mx)
Definition: imgui_internal.h:218
ImGuiGroupData::BackupGroupOffset
ImVec1 BackupGroupOffset
Definition: imgui_internal.h:498
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
ImGuiInputReadMode_RepeatFast
Definition: imgui_internal.h:388
ImCos
static float ImCos(float x)
Definition: imgui_internal.h:207
ImGuiColorEditFlags
int ImGuiColorEditFlags
Definition: imgui.h:132
ImGuiInputSource_None
Definition: imgui_internal.h:372
ImGuiContext::DragDropTargetRect
ImRect DragDropTargetRect
Definition: imgui_internal.h:827
ImGuiWindow::RootWindowForNav
ImGuiWindow * RootWindowForNav
Definition: imgui_internal.h:1146
ImGuiWindow::WantCollapseToggle
bool WantCollapseToggle
Definition: imgui_internal.h:1106
operator*
b2Vec2 operator*(float s, const b2Vec2 &a)
Definition: b2_math.h:446
ImGui::BeginTabBarEx
IMGUI_API bool BeginTabBarEx(ImGuiTabBar *tab_bar, const ImRect &bb, ImGuiTabBarFlags flags)
Definition: imgui_widgets.cpp:5839
ImGuiLayoutType
int ImGuiLayoutType
Definition: imgui_internal.h:75
ImGuiNavMoveFlags
int ImGuiNavMoveFlags
Definition: imgui_internal.h:84
ImGuiContext::FramerateSecPerFrameAccum
float FramerateSecPerFrameAccum
Definition: imgui_internal.h:875
ImGui::SetFocusID
IMGUI_API void SetFocusID(ImGuiID id, ImGuiWindow *window)
Definition: imgui.cpp:2595
ImGuiAxis
ImGuiAxis
Definition: imgui_internal.h:357
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
ImGuiContext::TabBars
ImPool< ImGuiTabBar > TabBars
Definition: imgui_internal.h:838
ImGui::TabBarFindTabByID
IMGUI_API ImGuiTabItem * TabBarFindTabByID(ImGuiTabBar *tab_bar, ImGuiID tab_id)
Definition: imgui_widgets.cpp:6089
ImGuiNextWindowData::SizeCallback
ImGuiSizeCallback SizeCallback
Definition: imgui_internal.h:681
ImParseFormatPrecision
IMGUI_API int ImParseFormatPrecision(const char *format, int default_value)
Definition: imgui_widgets.cpp:2585
ImTextStrToUtf8
IMGUI_API int ImTextStrToUtf8(char *buf, int buf_size, const ImWchar *in_text, const ImWchar *in_text_end)
Definition: imgui.cpp:1678
ImGuiSeparatorFlags_Horizontal
Definition: imgui_internal.h:329
ImGui::CalcWindowExpectedSize
IMGUI_API ImVec2 CalcWindowExpectedSize(ImGuiWindow *window)
Definition: imgui.cpp:4512
ImGuiColumnsFlags_None
Definition: imgui_internal.h:309
ImGui::IsDragDropPayloadBeingAccepted
IMGUI_API bool IsDragDropPayloadBeingAccepted()
Definition: imgui.cpp:8542
ImGui::GetWindowAllowedExtentRect
IMGUI_API ImRect GetWindowAllowedExtentRect(ImGuiWindow *window)
Definition: imgui.cpp:6863
ImGuiContext::PlatformImePos
ImVec2 PlatformImePos
Definition: imgui_internal.h:856
ImGuiWindowTempData::LayoutType
ImGuiLayoutType LayoutType
Definition: imgui_internal.h:1029
ImGuiWindowTempData::ItemFlagsStack
ImVector< ImGuiItemFlags > ItemFlagsStack
Definition: imgui_internal.h:1036
ImGuiContext::DragDropSourceFlags
ImGuiDragDropFlags DragDropSourceFlags
Definition: imgui_internal.h:823
ImGuiPlotType_Histogram
Definition: imgui_internal.h:367
ImGuiButtonFlags_
ImGuiButtonFlags_
Definition: imgui_internal.h:275
ImGuiContext::FontAtlasOwnedByContext
bool FontAtlasOwnedByContext
Definition: imgui_internal.h:720
ImGuiTabBar::SelectedTabId
ImGuiID SelectedTabId
Definition: imgui_internal.h:1224
ImGuiTabBar::Tabs
ImVector< ImGuiTabItem > Tabs
Definition: imgui_internal.h:1222
ImIsPowerOfTwo
static bool ImIsPowerOfTwo(int v)
Definition: imgui_internal.h:149
ImVector::resize
void resize(int new_size)
Definition: imgui.h:1201
IM_ARRAYSIZE
#define IM_ARRAYSIZE(_ARR)
Definition: imgui.h:73
ImGuiGroupData::BackupCurrentLineTextBaseOffset
float BackupCurrentLineTextBaseOffset
Definition: imgui_internal.h:500
ImSin
static float ImSin(float x)
Definition: imgui_internal.h:208
ImGuiWindow::SetWindowPosVal
ImVec2 SetWindowPosVal
Definition: imgui_internal.h:1124
ImGuiWindow::TitleBarRect
ImRect TitleBarRect() const
Definition: imgui_internal.h:1175
ImFloor
static float ImFloor(float f)
Definition: imgui_internal.h:232
ImGuiWindow::StateStorage
ImGuiStorage StateStorage
Definition: imgui_internal.h:1136
ImGuiContext::NavScoringRectScreen
ImRect NavScoringRectScreen
Definition: imgui_internal.h:784
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
ImGui::SetCurrentFont
IMGUI_API void SetCurrentFont(ImFont *font)
Definition: imgui.cpp:5538
ImGuiContext::ActiveIdPreviousFrameIsAlive
bool ActiveIdPreviousFrameIsAlive
Definition: imgui_internal.h:753
ImGuiNavMoveFlags_WrapX
Definition: imgui_internal.h:413
ImGuiNavMoveFlags_None
Definition: imgui_internal.h:410
ImGui::GetDefaultFont
ImFont * GetDefaultFont()
Definition: imgui_internal.h:1277
ImGuiPlotType
ImGuiPlotType
Definition: imgui_internal.h:364
ImGuiButtonFlags_PressedOnClick
Definition: imgui_internal.h:280
ImGuiInputReadMode
ImGuiInputReadMode
Definition: imgui_internal.h:381
ImGuiNavMoveFlags_
ImGuiNavMoveFlags_
Definition: imgui_internal.h:408
ImGuiWindow::CalcFontSize
float CalcFontSize() const
Definition: imgui_internal.h:1173
ImDrawList::_Data
const ImDrawListSharedData * _Data
Definition: imgui.h:1796
ImGuiWindow::MenuColumns
ImGuiMenuColumns MenuColumns
Definition: imgui_internal.h:1135
ImGuiWindow::WindowRounding
float WindowRounding
Definition: imgui_internal.h:1092
ImGui::UpdateHoveredWindowAndCaptureFlags
IMGUI_API void UpdateHoveredWindowAndCaptureFlags()
Definition: imgui.cpp:3229
ImGuiColumnsFlags_NoForceWithinWindow
Definition: imgui_internal.h:313
ImGui::TreeNodeBehavior
IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *label, const char *label_end=NULL)
Definition: imgui_widgets.cpp:4740
ImGuiContext::NavInputSource
ImGuiInputSource NavInputSource
Definition: imgui_internal.h:783
ImGuiStb::STB_TexteditState::has_preferred_x
unsigned char has_preferred_x
Definition: imgui_internal.h:345
ImFontAtlasBuildSetupFont
IMGUI_API void ImFontAtlasBuildSetupFont(ImFontAtlas *atlas, ImFont *font, ImFontConfig *font_config, float ascent, float descent)
Definition: imgui_draw.cpp:1965
ImFontAtlasBuildMultiplyCalcLookupTable
IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor)
Definition: imgui_draw.cpp:1719
ImGuiItemFlags
int ImGuiItemFlags
Definition: imgui_internal.h:80
ImStrlenW
IMGUI_API int ImStrlenW(const ImWchar *str)
Definition: imgui.cpp:1312
ImGui::SetNavID
IMGUI_API void SetNavID(ImGuiID id, int nav_layer)
Definition: imgui.cpp:2550
ImTextCountUtf8BytesFromChar
IMGUI_API int ImTextCountUtf8BytesFromChar(const char *in_text, const char *in_text_end)
Definition: imgui.cpp:1663
ImRect::GetCenter
ImVec2 GetCenter() const
Definition: imgui_internal.h:451
ImFontAtlas::Fonts
ImVector< ImFont * > Fonts
Definition: imgui.h:2059
ImGui::GetWindowScrollMaxY
IMGUI_API float GetWindowScrollMaxY(ImGuiWindow *window)
Definition: imgui.cpp:4523
ImRotate
static ImVec2 ImRotate(const ImVec2 &v, float cos_a, float sin_a)
Definition: imgui_internal.h:235
ImGuiContext::ColorModifiers
ImVector< ImGuiColorMod > ColorModifiers
Definition: imgui_internal.h:764
ImTriangleClosestPoint
IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p)
Definition: imgui.cpp:1248
ImGuiContext::HoveredIdNotActiveTimer
float HoveredIdNotActiveTimer
Definition: imgui_internal.h:745
ImGuiContext::ColorEditOptions
ImGuiColorEditFlags ColorEditOptions
Definition: imgui_internal.h:846
ImGui::GetNavInputAmount
IMGUI_API float GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode)
Definition: imgui.cpp:7349
ImGuiStb::STB_TexteditState::select_start
int select_start
Definition: imgui_internal.h:328
ImGuiButtonFlags_PressedOnRelease
Definition: imgui_internal.h:281
ImGuiContext::CurrentWindowStack
ImVector< ImGuiWindow * > CurrentWindowStack
Definition: imgui_internal.h:735
ImLerp
static T ImLerp(T a, T b, float t)
Definition: imgui_internal.h:219
ImGuiSliderFlags_None
Definition: imgui_internal.h:296
ImGui::RenderArrowPointingAt
IMGUI_API void RenderArrowPointingAt(ImDrawList *draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col)
Definition: imgui_draw.cpp:2885
ImGuiButtonFlags_PressedOnClickRelease
Definition: imgui_internal.h:279
ImGuiStorage::Data
ImVector< Pair > Data
Definition: imgui.h:1607
ImGuiDragDropFlags
int ImGuiDragDropFlags
Definition: imgui.h:136
ImGuiIO::KeyMap
int KeyMap[ImGuiKey_COUNT]
Definition: imgui.h:1285
t
geometry_msgs::TransformStamped t
ImGuiContext::FontStack
ImVector< ImFont * > FontStack
Definition: imgui_internal.h:766
ImGuiContext::NavActivatePressedId
ImGuiID NavActivatePressedId
Definition: imgui_internal.h:778
ImGui::ActivateItem
IMGUI_API void ActivateItem(ImGuiID id)
Definition: imgui.cpp:6304
ImGuiNavLayer_Main
Definition: imgui_internal.h:428
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
ImRect::Add
void Add(const ImRect &r)
Definition: imgui_internal.h:463
ImGuiContext::NavMoveRequestFlags
ImGuiNavMoveFlags NavMoveRequestFlags
Definition: imgui_internal.h:805
ImGuiWindowTempData::ItemFlags
ImGuiItemFlags ItemFlags
Definition: imgui_internal.h:1033
Add
void Add(const JntArray &src1, const JntArray &src2, JntArray &dest)
ImGui::BeginDragDropTargetCustom
IMGUI_API bool BeginDragDropTargetCustom(const ImRect &bb, ImGuiID id)
Definition: imgui.cpp:8490
ImGuiWindow::DrawList
ImDrawList * DrawList
Definition: imgui_internal.h:1141
ImGuiWindow::SetWindowPosPivot
ImVec2 SetWindowPosPivot
Definition: imgui_internal.h:1125
ImGuiContext::DrawDataBuilder
ImDrawDataBuilder DrawDataBuilder
Definition: imgui_internal.h:815
ImGui::CreateNewWindowSettings
IMGUI_API ImGuiWindowSettings * CreateNewWindowSettings(const char *name)
Definition: imgui.cpp:8799
ImGuiInputReadMode_Repeat
Definition: imgui_internal.h:386
ImGui::GetHoveredID
IMGUI_API ImGuiID GetHoveredID()
Definition: imgui.cpp:2631
ImWchar
unsigned short ImWchar
Definition: imgui.h:119
ImGui::IsNavInputPressed
bool IsNavInputPressed(ImGuiNavInput n, ImGuiInputReadMode mode)
Definition: imgui_internal.h:1349
ImGui::ItemSize
IMGUI_API void ItemSize(const ImRect &bb, float text_offset_y=0.0f)
Definition: imgui.cpp:2706
ImGuiCond
int ImGuiCond
Definition: imgui.h:121
ImGui::GetWindowScrollMaxX
IMGUI_API float GetWindowScrollMaxX(ImGuiWindow *window)
Definition: imgui.cpp:4518
ImGuiNavHighlightFlags_NoRounding
Definition: imgui_internal.h:397
ImGuiInputTextFlags
int ImGuiInputTextFlags
Definition: imgui.h:139
ImGuiContext::ActiveId
ImGuiID ActiveId
Definition: imgui_internal.h:746
ImGuiDir
int ImGuiDir
Definition: imgui.h:123
ImGui::FindBestWindowPosForPopup
IMGUI_API ImVec2 FindBestWindowPosForPopup(ImGuiWindow *window)
Definition: imgui.cpp:6926
ImGuiGroupData::BackupCurrentLineSize
ImVec2 BackupCurrentLineSize
Definition: imgui_internal.h:499
ImGuiContext::NavMoveClipDir
ImGuiDir NavMoveClipDir
Definition: imgui_internal.h:808
ImGuiItemStatusFlags_None
Definition: imgui_internal.h:336
ImGuiWindowTempData::ParentLayoutType
ImGuiLayoutType ParentLayoutType
Definition: imgui_internal.h:1030
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
ImGuiItemFlags_NoNav
Definition: imgui_internal.h:994
ImGuiInputSource_Nav
Definition: imgui_internal.h:374
ImFileOpen
IMGUI_API FILE * ImFileOpen(const char *filename, const char *file_open_mode)
Definition: imgui.cpp:1467
ImParseFormatFindEnd
IMGUI_API const char * ImParseFormatFindEnd(const char *format)
Definition: imgui_widgets.cpp:2549
ImGuiContext::DragSpeedDefaultRatio
float DragSpeedDefaultRatio
Definition: imgui_internal.h:850
ImHash
IMGUI_API ImU32 ImHash(const void *data, int data_size, ImU32 seed=0)
Definition: imgui.cpp:1425
ImGui::RenderArrow
IMGUI_API void RenderArrow(ImVec2 pos, ImGuiDir dir, float scale=1.0f)
Definition: imgui.cpp:2338
ImGuiWindow::NavLastChildNavWindow
ImGuiWindow * NavLastChildNavWindow
Definition: imgui_internal.h:1148
ImGuiContext::Windows
ImVector< ImGuiWindow * > Windows
Definition: imgui_internal.h:732
IM_ASSERT
#define IM_ASSERT(_EXPR)
Definition: imgui.h:64
ImGuiContext::WantTextInputNextFrame
int WantTextInputNextFrame
Definition: imgui_internal.h:878
ImGuiWindowFlags
int ImGuiWindowFlags
Definition: imgui.h:144
ImGuiContext::NavWindowingToggleLayer
bool NavWindowingToggleLayer
Definition: imgui_internal.h:791
IMGUI_API
#define IMGUI_API
Definition: imgui.h:55
ImRect::GetSize
ImVec2 GetSize() const
Definition: imgui_internal.h:452
ImGuiInputSource_Mouse
Definition: imgui_internal.h:373
ImRect::ImRect
ImRect(const ImVec4 &v)
Definition: imgui_internal.h:448
ImGuiWindow::SizeContentsExplicit
ImVec2 SizeContentsExplicit
Definition: imgui_internal.h:1090
ImGuiContext::NavMoveRequestForward
ImGuiNavForward NavMoveRequestForward
Definition: imgui_internal.h:806
ImPool::Add
T * Add()
Definition: imgui_internal.h:256
ImGuiNavMoveFlags_LoopY
Definition: imgui_internal.h:412
ImGui::KeepAliveID
IMGUI_API void KeepAliveID(ImGuiID id)
Definition: imgui.cpp:2637
ImRect::Expand
void Expand(const float amount)
Definition: imgui_internal.h:464
ImGuiContext::InputTextState
ImGuiInputTextState InputTextState
Definition: imgui_internal.h:843
ImGuiTabBar::ContentsHeight
float ContentsHeight
Definition: imgui_internal.h:1230
ImStrnicmp
IMGUI_API int ImStrnicmp(const char *str1, const char *str2, size_t count)
Definition: imgui.cpp:1271
ImGuiPopupRef::OpenParentId
ImGuiID OpenParentId
Definition: imgui_internal.h:581
ImGuiButtonFlags_AlignTextBaseLine
Definition: imgui_internal.h:287
ImVec4::w
float w
Definition: imgui.h:178
ImGuiInputTextState::UserCallback
ImGuiInputTextCallback UserCallback
Definition: imgui_internal.h:538
ImGuiContext::InputTextPasswordFont
ImFont InputTextPasswordFont
Definition: imgui_internal.h:844
ImSwap
static void ImSwap(T &a, T &b)
Definition: imgui_internal.h:220
ImLengthSqr
static float ImLengthSqr(const ImVec2 &lhs)
Definition: imgui_internal.h:229
ImGuiStorage::GetInt
IMGUI_API int GetInt(ImGuiID key, int default_val=0) const
Definition: imgui.cpp:1861
ImGuiContext::NavInitRequestFromMove
bool NavInitRequestFromMove
Definition: imgui_internal.h:800
ImGuiStb::STB_TexteditState::select_end
int select_end
Definition: imgui_internal.h:329
ImPool::GetByKey
T * GetByKey(ImGuiID key)
Definition: imgui_internal.h:251
ImDot
static float ImDot(const ImVec2 &a, const ImVec2 &b)
Definition: imgui_internal.h:234
ImGuiColumnsSet::Flags
ImGuiColumnsFlags Flags
Definition: imgui_internal.h:599
ImGuiTabBar::Flags
ImGuiTabBarFlags Flags
Definition: imgui_internal.h:1235
ImRect::ClipWith
void ClipWith(const ImRect &r)
Definition: imgui_internal.h:469
ImGuiWindow::SizeFullAtLastBegin
ImVec2 SizeFullAtLastBegin
Definition: imgui_internal.h:1088
operator+
b2Vec2 operator+(const b2Vec2 &a, const b2Vec2 &b)
Add two vectors component-wise.
Definition: b2_math.h:435
ImGuiNavLayer
ImGuiNavLayer
Definition: imgui_internal.h:426
ImGui::ColorTooltip
IMGUI_API void ColorTooltip(const char *text, const float *col, ImGuiColorEditFlags flags)
Definition: imgui_widgets.cpp:4482
ImGuiContext::NavJustTabbedId
ImGuiID NavJustTabbedId
Definition: imgui_internal.h:780
ImGui::TreePushRawID
IMGUI_API void TreePushRawID(ImGuiID id)
Definition: imgui_widgets.cpp:4903
ImGui::PushItemFlag
IMGUI_API void PushItemFlag(ImGuiItemFlags option, bool enabled)
Definition: imgui.cpp:5571
ImGuiWindow::RootWindow
ImGuiWindow * RootWindow
Definition: imgui_internal.h:1144
ImGuiContext::NavWindowingTargetAnim
ImGuiWindow * NavWindowingTargetAnim
Definition: imgui_internal.h:787
ImStrncpy
IMGUI_API void ImStrncpy(char *dst, const char *src, size_t count)
Definition: imgui.cpp:1278
ImGui::TabItemEx
IMGUI_API bool TabItemEx(ImGuiTabBar *tab_bar, const char *label, bool *p_open, ImGuiTabItemFlags flags)
Definition: imgui_widgets.cpp:6252
ImGuiNavDirSourceFlags_PadDPad
Definition: imgui_internal.h:404
ImGuiContext::NavLayer
ImGuiNavLayer NavLayer
Definition: imgui_internal.h:792
ImGui::Scrollbar
IMGUI_API void Scrollbar(ImGuiLayoutType direction)
Definition: imgui_widgets.cpp:707
ImStricmp
IMGUI_API int ImStricmp(const char *str1, const char *str2)
Definition: imgui.cpp:1264
ImRect::Max
ImVec2 Max
Definition: imgui_internal.h:444
ImGuiButtonFlags_FlattenChildren
Definition: imgui_internal.h:283
ImDrawList::_OwnerName
const char * _OwnerName
Definition: imgui.h:1797
ImVector::Data
T * Data
Definition: imgui.h:1170
ImGuiGroupData::BackupActiveIdPreviousFrameIsAlive
bool BackupActiveIdPreviousFrameIsAlive
Definition: imgui_internal.h:503
ImGuiInputTextState::StbState
ImGuiStb::STB_TexteditState StbState
Definition: imgui_internal.h:531
ImFabs
static float ImFabs(float x)
Definition: imgui_internal.h:201
ImGuiWindow::ItemWidthDefault
float ItemWidthDefault
Definition: imgui_internal.h:1134
ImGui::FocusWindow
IMGUI_API void FocusWindow(ImGuiWindow *window)
Definition: imgui.cpp:5444
ImGuiContext::ActiveIdWindow
ImGuiWindow * ActiveIdWindow
Definition: imgui_internal.h:757
ImGuiContext::SettingsIniData
ImGuiTextBuffer SettingsIniData
Definition: imgui_internal.h:861
ImStrchrRange
IMGUI_API const char * ImStrchrRange(const char *str_begin, const char *str_end, char c)
Definition: imgui.cpp:1306
ImGuiContext::NavWindowingTimer
float NavWindowingTimer
Definition: imgui_internal.h:789
ImPool::FreeIdx
ImPoolIdx FreeIdx
Definition: imgui_internal.h:247
ImTriangleContainsPoint
IMGUI_API bool ImTriangleContainsPoint(const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p)
Definition: imgui.cpp:1229
ImGuiContext::NavWindowingTarget
ImGuiWindow * NavWindowingTarget
Definition: imgui_internal.h:786
ImGuiContext::StyleModifiers
ImVector< ImGuiStyleMod > StyleModifiers
Definition: imgui_internal.h:765
ImGui::RenderNavHighlight
IMGUI_API void RenderNavHighlight(const ImRect &bb, ImGuiID id, ImGuiNavHighlightFlags flags=ImGuiNavHighlightFlags_TypeDefault)
Definition: imgui.cpp:2397
ImGuiWindow::AutoPosLastDirection
ImGuiDir AutoPosLastDirection
Definition: imgui_internal.h:1118
ImGuiContext::DragCurrentAccumDirty
bool DragCurrentAccumDirty
Definition: imgui_internal.h:848
ImGuiWindow::ContentsRegionRect
ImRect ContentsRegionRect
Definition: imgui_internal.h:1132
ImGuiStyleVar
int ImGuiStyleVar
Definition: imgui.h:127
ImGuiContext::DrawListSharedData
ImDrawListSharedData DrawListSharedData
Definition: imgui_internal.h:726
ImGuiContext::HoveredIdPreviousFrame
ImGuiID HoveredIdPreviousFrame
Definition: imgui_internal.h:743
ImGui::ItemAdd
IMGUI_API bool ItemAdd(const ImRect &bb, ImGuiID id, const ImRect *nav_bb=NULL)
Definition: imgui.cpp:2714
ImGuiItemStatusFlags_
ImGuiItemStatusFlags_
Definition: imgui_internal.h:334
ImGuiContext::DragDropTargetId
ImGuiID DragDropTargetId
Definition: imgui_internal.h:828
ImGuiColumnsSet::Columns
ImVector< ImGuiColumnData > Columns
Definition: imgui_internal.h:608
ImGuiContext::CurrentTabBar
ImVector< ImGuiTabBar * > CurrentTabBar
Definition: imgui_internal.h:839
ImGuiKey
int ImGuiKey
Definition: imgui.h:124
ImGuiPlotType_Lines
Definition: imgui_internal.h:366
ImGuiLayoutType_Vertical
Definition: imgui_internal.h:353
ImMax
static T ImMax(T lhs, T rhs)
Definition: imgui_internal.h:217
ImGui::Shutdown
IMGUI_API void Shutdown(ImGuiContext *context)
Definition: imgui.cpp:3491
ImGui::GetFrontMostPopupModal
IMGUI_API ImGuiWindow * GetFrontMostPopupModal()
Definition: imgui.cpp:6600
ImVec4::z
float z
Definition: imgui.h:178
ImGuiSelectableFlags_PressedOnClick
Definition: imgui_internal.h:321
ImGuiNavDirSourceFlags
int ImGuiNavDirSourceFlags
Definition: imgui_internal.h:83
ImPool::GetIndex
ImPoolIdx GetIndex(const T *p) const
Definition: imgui_internal.h:253
ImFontAtlasBuildFinish
IMGUI_API void ImFontAtlasBuildFinish(ImFontAtlas *atlas)
Definition: imgui_draw.cpp:2036
ImGuiSeparatorFlags_None
Definition: imgui_internal.h:328
ImGuiWindow::WindowPadding
ImVec2 WindowPadding
Definition: imgui_internal.h:1091
ImGuiContext::FrameScopePushedImplicitWindow
bool FrameScopePushedImplicitWindow
Definition: imgui_internal.h:719
ImGuiButtonFlags_Repeat
Definition: imgui_internal.h:278
ImGui::IsWindowNavFocusable
IMGUI_API bool IsWindowNavFocusable(ImGuiWindow *window)
Definition: imgui.cpp:5877
ImGuiContext::NavInitResultId
ImGuiID NavInitResultId
Definition: imgui_internal.h:801
ImGuiDragFlags_
ImGuiDragFlags_
Definition: imgui_internal.h:300
ImGuiButtonFlags_Disabled
Definition: imgui_internal.h:286
ImGuiItemFlags_ButtonRepeat
Definition: imgui_internal.h:992
ImGuiContext::ActiveIdPreviousFrame
ImGuiID ActiveIdPreviousFrame
Definition: imgui_internal.h:747
ImGui::VerticalSeparator
IMGUI_API void VerticalSeparator()
Definition: imgui_widgets.cpp:1175
ImGuiWindow::BeginOrderWithinParent
short BeginOrderWithinParent
Definition: imgui_internal.h:1112
ImGuiItemStatusFlags_HasDisplayRect
Definition: imgui_internal.h:338
ImGuiContext::WindowsFocusOrder
ImVector< ImGuiWindow * > WindowsFocusOrder
Definition: imgui_internal.h:733
ImGuiButtonFlags_NoKeyModifiers
Definition: imgui_internal.h:288
ImGui::SetNavIDWithRectRel
IMGUI_API void SetNavIDWithRectRel(ImGuiID id, int nav_layer, const ImRect &rect_rel)
Definition: imgui.cpp:2559
ImGui::Initialize
IMGUI_API void Initialize(ImGuiContext *context)
Definition: imgui.cpp:3473
ImGuiID
unsigned int ImGuiID
Definition: imgui.h:118
ImInvLength
static float ImInvLength(const ImVec2 &lhs, float fail_value)
Definition: imgui_internal.h:231
ImGuiContext::SettingsWindows
ImVector< ImGuiWindowSettings > SettingsWindows
Definition: imgui_internal.h:863
ImGuiNavMoveFlags_LoopX
Definition: imgui_internal.h:411
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
ImGui::StartMouseMovingWindow
IMGUI_API void StartMouseMovingWindow(ImGuiWindow *window)
Definition: imgui.cpp:3020
ImGuiInputSource_NavGamepad
Definition: imgui_internal.h:376
ImGuiWindow::ScrollTargetCenterRatio
ImVec2 ScrollTargetCenterRatio
Definition: imgui_internal.h:1099
ImGui::MarkItemEdited
IMGUI_API void MarkItemEdited(ImGuiID id)
Definition: imgui.cpp:2646
ImGuiContext::HoveredRootWindow
ImGuiWindow * HoveredRootWindow
Definition: imgui_internal.h:740
ImGuiWindow::FocusIdxTabRequestCurrent
int FocusIdxTabRequestCurrent
Definition: imgui_internal.h:1157
ImGuiContext::LastActiveId
ImGuiID LastActiveId
Definition: imgui_internal.h:760
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
ImGui::FocusableItemUnregister
IMGUI_API void FocusableItemUnregister(ImGuiWindow *window)
Definition: imgui.cpp:2855
ImRect::ImRect
ImRect(float x1, float y1, float x2, float y2)
Definition: imgui_internal.h:449
ImVec4
Definition: imgui.h:176
ImGuiContext::MovingWindow
ImGuiWindow * MovingWindow
Definition: imgui_internal.h:763
ImVector::Size
int Size
Definition: imgui.h:1168
ImGuiSelectableFlags_PressedOnRelease
Definition: imgui_internal.h:322
ImGuiSliderFlags
int ImGuiSliderFlags
Definition: imgui_internal.h:86
ImGuiContext::ScalarAsInputTextId
ImGuiID ScalarAsInputTextId
Definition: imgui_internal.h:845
ImGui::ColorPickerOptionsPopup
IMGUI_API void ColorPickerOptionsPopup(const float *ref_col, ImGuiColorEditFlags flags)
Definition: imgui_widgets.cpp:4554
ImGui::BringWindowToFocusFront
IMGUI_API void BringWindowToFocusFront(ImGuiWindow *window)
Definition: imgui.cpp:5400
ImGuiNavDirSourceFlags_None
Definition: imgui_internal.h:402
ImGuiContext::LogClipboard
ImGuiTextBuffer LogClipboard
Definition: imgui_internal.h:868
ImGuiContext::DragDropAcceptIdCurrRectSurface
float DragDropAcceptIdCurrRectSurface
Definition: imgui_internal.h:830
ImGuiMouseCursor
int ImGuiMouseCursor
Definition: imgui.h:126
imstb_textedit.h
ImGuiItemStatusFlags_Edited
Definition: imgui_internal.h:339
ImSqrt
static float ImSqrt(float x)
Definition: imgui_internal.h:202
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
ImGui::BringWindowToDisplayBack
IMGUI_API void BringWindowToDisplayBack(ImGuiWindow *window)
Definition: imgui.cpp:5429
ImGuiTabBarFlags
int ImGuiTabBarFlags
Definition: imgui.h:141
ImGuiTabItemFlags
int ImGuiTabItemFlags
Definition: imgui.h:142
ImGuiWindow::HiddenFramesForResize
int HiddenFramesForResize
Definition: imgui_internal.h:1120
ImRect::TranslateY
void TranslateY(float dy)
Definition: imgui_internal.h:468
ImGuiContext::NavWindowingList
ImGuiWindow * NavWindowingList
Definition: imgui_internal.h:788
ImGuiLayoutType_Horizontal
Definition: imgui_internal.h:354
ImGuiPopupRef::ParentWindow
ImGuiWindow * ParentWindow
Definition: imgui_internal.h:579
ImGuiSelectableFlagsPrivate_
ImGuiSelectableFlagsPrivate_
Definition: imgui_internal.h:317
ImGui::RenderTextWrapped
IMGUI_API void RenderTextWrapped(ImVec2 pos, const char *text, const char *text_end, float wrap_width)
Definition: imgui.cpp:2250
ImGuiWindow::BeginOrderWithinContext
short BeginOrderWithinContext
Definition: imgui_internal.h:1113
ImGui::CollapseButton
IMGUI_API bool CollapseButton(ImGuiID id, const ImVec2 &pos)
Definition: imgui_widgets.cpp:680
ImCharIsBlankA
static bool ImCharIsBlankA(char c)
Definition: imgui_internal.h:147
ImGui::ClearDragDrop
IMGUI_API void ClearDragDrop()
Definition: imgui.cpp:8317
ImGuiNavForward_None
Definition: imgui_internal.h:421
ImGui::RenderBullet
IMGUI_API void RenderBullet(ImVec2 pos)
Definition: imgui.cpp:2372
ImGuiSelectableFlags_NoHoldingActiveID
Definition: imgui_internal.h:320
ImVec4::x
float x
Definition: imgui.h:178
ImRect::ImRect
ImRect(const ImVec2 &min, const ImVec2 &max)
Definition: imgui_internal.h:447
ImGuiSeparatorFlags_Vertical
Definition: imgui_internal.h:330
ImGuiItemFlags_
ImGuiItemFlags_
Definition: imgui_internal.h:989
ImGuiContext::OpenPopupStack
ImVector< ImGuiPopupRef > OpenPopupStack
Definition: imgui_internal.h:767
ImGuiGroupData::BackupActiveIdIsAlive
ImGuiID BackupActiveIdIsAlive
Definition: imgui_internal.h:502
ImGuiTabBarFlags_IsFocused
Definition: imgui_internal.h:1201
ImGuiContext::DragDropAcceptIdPrev
ImGuiID DragDropAcceptIdPrev
Definition: imgui_internal.h:832
ImGuiAxis_Y
Definition: imgui_internal.h:361
ImGui::ButtonEx
IMGUI_API bool ButtonEx(const char *label, const ImVec2 &size_arg=ImVec2(0, 0), ImGuiButtonFlags flags=0)
Definition: imgui_widgets.cpp:534
ImGuiContext::PrivateClipboard
ImVector< char > PrivateClipboard
Definition: imgui_internal.h:853
ImGuiContext::LastActiveIdTimer
float LastActiveIdTimer
Definition: imgui_internal.h:761
ImGuiWindow::SetWindowCollapsedAllowFlags
ImGuiCond SetWindowCollapsedAllowFlags
Definition: imgui_internal.h:1123
ImGui::BeginColumns
IMGUI_API void BeginColumns(const char *str_id, int count, ImGuiColumnsFlags flags=0)
Definition: imgui.cpp:8164
void
typedef void(GLAD_API_PTR *GLDEBUGPROC)(GLenum source
ImPool::Clear
void Clear()
Definition: imgui_internal.h:255
ImGuiContext::SettingsDirtyTimer
float SettingsDirtyTimer
Definition: imgui_internal.h:860
ImGuiContext::CurrentWindow
ImGuiWindow * CurrentWindow
Definition: imgui_internal.h:738
ImRect::GetTR
ImVec2 GetTR() const
Definition: imgui_internal.h:456
ImVec2::y
float y
Definition: imgui.h:166
ImGuiContext::Style
ImGuiStyle Style
Definition: imgui_internal.h:722
ImGuiAxis_None
Definition: imgui_internal.h:359
ImGuiSelectableFlags_DrawFillAvailWidth
Definition: imgui_internal.h:323
ImTextCountUtf8BytesFromStr
IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar *in_text, const ImWchar *in_text_end)
Definition: imgui.cpp:1694
ImGui::MarkIniSettingsDirty
IMGUI_API void MarkIniSettingsDirty(ImGuiWindow *window)
Definition: imgui.cpp:8791
ImGuiWindow::InnerMainRect
ImRect InnerMainRect
Definition: imgui_internal.h:1131
ImGuiStyle::FramePadding
ImVec2 FramePadding
Definition: imgui.h:1236
ImGuiButtonFlags_AllowItemOverlap
Definition: imgui_internal.h:284
ImGuiSeparatorFlags
int ImGuiSeparatorFlags
Definition: imgui_internal.h:85
ImGuiContext::DragDropAcceptFrameCount
int DragDropAcceptFrameCount
Definition: imgui_internal.h:833
ImGui::FocusPreviousWindowIgnoringOne
IMGUI_API void FocusPreviousWindowIgnoringOne(ImGuiWindow *ignore_window)
Definition: imgui.cpp:5479
ImRect::Contains
bool Contains(const ImRect &r) const
Definition: imgui_internal.h:460
ImFormatString
IMGUI_API int ImFormatString(char *buf, size_t buf_size, const char *fmt,...) IM_FMTARGS(3)
Definition: imgui.cpp:1387
ImGuiContext::LogAutoExpandMaxDepth
int LogAutoExpandMaxDepth
Definition: imgui_internal.h:870
ImFontAtlasBuildPackCustomRects
IMGUI_API void ImFontAtlasBuildPackCustomRects(ImFontAtlas *atlas, void *spc)
Definition: imgui_draw.cpp:1979
ImGuiNavHighlightFlags_None
Definition: imgui_internal.h:393
ImGui::IsNavInputPressedAnyOfTwo
bool IsNavInputPressedAnyOfTwo(ImGuiNavInput n1, ImGuiNavInput n2, ImGuiInputReadMode mode)
Definition: imgui_internal.h:1350
ImPool::GetOrAddByKey
T * GetOrAddByKey(ImGuiID key)
Definition: imgui_internal.h:254
pow
INLINE Rall1d< T, V, S > pow(const Rall1d< T, V, S > &arg, double m)
ImGuiNavForward_ForwardQueued
Definition: imgui_internal.h:422
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
ImGuiWindow::Flags
ImGuiWindowFlags Flags
Definition: imgui_internal.h:1084
ImGuiItemFlags_NoNavDefaultFocus
Definition: imgui_internal.h:995
ImVector::clear
void clear()
Definition: imgui.h:1189
ImGuiColumnsFlags_
ImGuiColumnsFlags_
Definition: imgui_internal.h:306
ImPoolIdx
int ImPoolIdx
Definition: imgui_internal.h:241
ImGuiStorage::SetInt
IMGUI_API void SetInt(ImGuiID key, int val)
Definition: imgui.cpp:1921
ImStrbolW
IMGUI_API const ImWchar * ImStrbolW(const ImWchar *buf_mid_line, const ImWchar *buf_begin)
Definition: imgui.cpp:1327
ImGuiTabBar::ReorderRequestTabId
ImGuiID ReorderRequestTabId
Definition: imgui_internal.h:1236
ImGuiStyleMod::ImGuiStyleMod
ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v)
Definition: imgui_internal.h:489
ImCeil
static float ImCeil(float x)
Definition: imgui_internal.h:213
ImGui::FindWindowByName
IMGUI_API ImGuiWindow * FindWindowByName(const char *name)
Definition: imgui.cpp:4387
ImGui::NavMoveRequestCancel
IMGUI_API void NavMoveRequestCancel()
Definition: imgui.cpp:7216
ImGuiContext::NavDisableHighlight
bool NavDisableHighlight
Definition: imgui_internal.h:796
ImStrdup
IMGUI_API char * ImStrdup(const char *str)
Definition: imgui.cpp:1285
ImGuiWindow::DrawListInst
ImDrawList DrawListInst
Definition: imgui_internal.h:1142
ImStristr
IMGUI_API const char * ImStristr(const char *haystack, const char *haystack_end, const char *needle, const char *needle_end)
Definition: imgui.cpp:1334
ImGui::OpenPopupEx
IMGUI_API void OpenPopupEx(ImGuiID id)
Definition: imgui.cpp:6620
ImGuiContext::ColorPickerRef
ImVec4 ColorPickerRef
Definition: imgui_internal.h:847
ImGuiContext::DragDropAcceptFlags
ImGuiDragDropFlags DragDropAcceptFlags
Definition: imgui_internal.h:829
ImGui::NavMoveRequestButNoResultYet
IMGUI_API bool NavMoveRequestButNoResultYet()
Definition: imgui.cpp:7210
ImGui::UpdateMouseMovingWindowEndFrame
IMGUI_API void UpdateMouseMovingWindowEndFrame()
Definition: imgui.cpp:3075
ImLineClosestPoint
IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2 &a, const ImVec2 &b, const ImVec2 &p)
Definition: imgui.cpp:1216
ImGuiContext::WindowsSortBuffer
ImVector< ImGuiWindow * > WindowsSortBuffer
Definition: imgui_internal.h:734
ImGuiContext::SettingsHandlers
ImVector< ImGuiSettingsHandler > SettingsHandlers
Definition: imgui_internal.h:862
ImGuiWindowTempData::TextWrapPosStack
ImVector< float > TextWrapPosStack
Definition: imgui_internal.h:1038
ImGui::SetWindowScrollY
IMGUI_API void SetWindowScrollY(ImGuiWindow *window, float new_scroll_y)
Definition: imgui.cpp:5908
ImGuiInputTextState::InitialText
ImVector< char > InitialText
Definition: imgui_internal.h:526
ImGuiSliderFlags_
ImGuiSliderFlags_
Definition: imgui_internal.h:294
ImGuiContext::NavMoveResultOther
ImGuiNavMoveResult NavMoveResultOther
Definition: imgui_internal.h:811
ImGuiTabBar::GetTabOrder
int GetTabOrder(const ImGuiTabItem *tab) const
Definition: imgui_internal.h:1243
ImGui::BeginTooltipEx
IMGUI_API void BeginTooltipEx(ImGuiWindowFlags extra_flags, bool override_previous_tooltip=true)
Definition: imgui.cpp:6541
ImGuiDataType
int ImGuiDataType
Definition: imgui.h:122
ImGuiButtonFlags_NoNavFocus
Definition: imgui_internal.h:291
ImGui::EndColumns
IMGUI_API void EndColumns()
Definition: imgui.cpp:8228
ImGuiContext::ActiveIdPreviousFrameWindow
ImGuiWindow * ActiveIdPreviousFrameWindow
Definition: imgui_internal.h:758
ImGuiWindow::FocusIdxAllRequestNext
int FocusIdxAllRequestNext
Definition: imgui_internal.h:1158
ImGuiWindow::ScrollbarSizes
ImVec2 ScrollbarSizes
Definition: imgui_internal.h:1100
ImGuiStorage::GetIntRef
IMGUI_API int * GetIntRef(ImGuiID key, int default_val=0)
Definition: imgui.cpp:1891
ImSaturate
static float ImSaturate(float f)
Definition: imgui_internal.h:228
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
ImRect::ClipWithFull
void ClipWithFull(const ImRect &r)
Definition: imgui_internal.h:470
ImGui::TabBarRemoveTab
IMGUI_API void TabBarRemoveTab(ImGuiTabBar *tab_bar, ImGuiID tab_id)
Definition: imgui_widgets.cpp:6099
ImFont
Definition: imgui.h:2071
ImGui::CalcTypematicPressedRepeatAmount
IMGUI_API int CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate)
Definition: imgui.cpp:3970
ImGuiContext::NavActivateDownId
ImGuiID NavActivateDownId
Definition: imgui_internal.h:777
ImGui::ItemHoverable
IMGUI_API bool ItemHoverable(const ImRect &bb, ImGuiID id)
Definition: imgui.cpp:2797
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
ImGui::TabBarCloseTab
IMGUI_API void TabBarCloseTab(ImGuiTabBar *tab_bar, ImGuiTabItem *tab)
Definition: imgui_widgets.cpp:6109
ImGui::GetActiveID
ImGuiID GetActiveID()
Definition: imgui_internal.h:1298
ImGuiStyleMod::ImGuiStyleMod
ImGuiStyleMod(ImGuiStyleVar idx, float v)
Definition: imgui_internal.h:488
ImGuiTabBar::VisibleTabId
ImGuiID VisibleTabId
Definition: imgui_internal.h:1226
ImGui::SetActiveID
IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow *window)
Definition: imgui.cpp:2569
ImGuiContext::NavWindow
ImGuiWindow * NavWindow
Definition: imgui_internal.h:774
ImRect::GetBR
ImVec2 GetBR() const
Definition: imgui_internal.h:458
ImParseFormatTrimDecorations
IMGUI_API const char * ImParseFormatTrimDecorations(const char *format, char *buf, int buf_size)
Definition: imgui_widgets.cpp:2571
ImGui::CloseButton
IMGUI_API bool CloseButton(ImGuiID id, const ImVec2 &pos, float radius)
Definition: imgui_widgets.cpp:651
ImGuiContext::BeginPopupStack
ImVector< ImGuiPopupRef > BeginPopupStack
Definition: imgui_internal.h:768
ImGui::RenderPixelEllipsis
IMGUI_API void RenderPixelEllipsis(ImDrawList *draw_list, ImVec2 pos, int count, ImU32 col)
Definition: imgui_draw.cpp:2968
ImGuiColumnData::OffsetNormBeforeResize
float OffsetNormBeforeResize
Definition: imgui_internal.h:589
ImGuiContext::HoveredIdAllowOverlap
bool HoveredIdAllowOverlap
Definition: imgui_internal.h:742
ImGuiContext::WantCaptureKeyboardNextFrame
int WantCaptureKeyboardNextFrame
Definition: imgui_internal.h:877
ImGuiDragFlags_Vertical
Definition: imgui_internal.h:303
ImGuiContext::NavMoveFromClampedRefRect
bool NavMoveFromClampedRefRect
Definition: imgui_internal.h:803
ImPool::Reserve
void Reserve(int capacity)
Definition: imgui_internal.h:259
ImGuiNavForward_ForwardActive
Definition: imgui_internal.h:423
ImVector::index_from_ptr
int index_from_ptr(const T *it) const
Definition: imgui.h:1214
ImPow
static float ImPow(float x, float y)
Definition: imgui_internal.h:203
ImGui::NavInitWindow
IMGUI_API void NavInitWindow(ImGuiWindow *window, bool force_reinit)
Definition: imgui.cpp:7306
ImFloorStd
static float ImFloorStd(float x)
Definition: imgui_internal.h:212
ImGui::SetWindowScrollX
IMGUI_API void SetWindowScrollX(ImGuiWindow *window, float new_scroll_x)
Definition: imgui.cpp:5901
ImGuiColumnsFlags_GrowParentContentsSize
Definition: imgui_internal.h:314
min
static int min(int n1, int n2)
Definition: wl_init.c:42
ImGuiButtonFlags_PressedOnDragDropHold
Definition: imgui_internal.h:290
ImGui::TreeNodeBehaviorIsOpen
IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags=0)
Definition: imgui_widgets.cpp:4693
ImFontAtlasBuildWithStbTruetype
IMGUI_API bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas *atlas)
Definition: imgui_draw.cpp:1736
ImFmod
static float ImFmod(float x, float y)
Definition: imgui_internal.h:205
ImAtof
static double ImAtof(const char *s)
Definition: imgui_internal.h:211
ImGui::CalcWrapWidthForPos
IMGUI_API float CalcWrapWidthForPos(const ImVec2 &pos, float wrap_pos_x)
Definition: imgui.cpp:2874
ImGuiWindowTempData::GroupStack
ImVector< ImGuiGroupData > GroupStack
Definition: imgui_internal.h:1039
ImGuiNavDirSourceFlags_
ImGuiNavDirSourceFlags_
Definition: imgui_internal.h:400
ImGui::TabItemBackground
IMGUI_API void TabItemBackground(ImDrawList *draw_list, const ImRect &bb, ImGuiTabItemFlags flags, ImU32 col)
Definition: imgui_widgets.cpp:6461
ImGui::RoundScalarWithFormatT
IMGUI_API T RoundScalarWithFormatT(const char *format, ImGuiDataType data_type, T v)
ImGuiWindow::ColumnsStorage
ImVector< ImGuiColumnsSet > ColumnsStorage
Definition: imgui_internal.h:1137
ImGuiContext::DragDropPayload
ImGuiPayload DragDropPayload
Definition: imgui_internal.h:826
ImStrTrimBlanks
IMGUI_API void ImStrTrimBlanks(char *str)
Definition: imgui.cpp:1357
ImFontAtlasBuildRegisterDefaultCustomRects
IMGUI_API void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas *atlas)
Definition: imgui_draw.cpp:1955
ImGui::TabBarQueueChangeTabOrder
IMGUI_API void TabBarQueueChangeTabOrder(ImGuiTabBar *tab_bar, const ImGuiTabItem *tab, int dir)
Definition: imgui_widgets.cpp:6144
ImTextCharFromUtf8
IMGUI_API int ImTextCharFromUtf8(unsigned int *out_char, const char *in_text, const char *in_text_end)
Definition: imgui.cpp:1532
ImGuiItemStatusFlags_HoveredRect
Definition: imgui_internal.h:337
ImGuiWindowTempData::LastItemStatusFlags
ImGuiItemStatusFlags LastItemStatusFlags
Definition: imgui_internal.h:1016
ImGuiStb::STB_TexteditState::cursor
int cursor
Definition: imgui_internal.h:325
ImGuiContext::ActiveIdHasBeenEdited
bool ActiveIdHasBeenEdited
Definition: imgui_internal.h:752
ImGuiLayoutType_
ImGuiLayoutType_
Definition: imgui_internal.h:351
ImGuiInputReadMode_Pressed
Definition: imgui_internal.h:384
ImGui::GetID
IMGUI_API ImGuiID GetID(const char *str_id)
Definition: imgui.cpp:6378
ImRect::Expand
void Expand(const ImVec2 &amount)
Definition: imgui_internal.h:465
ImGuiItemFlags_SelectableDontClosePopup
Definition: imgui_internal.h:996
ImGuiWindow::TitleBarHeight
float TitleBarHeight() const
Definition: imgui_internal.h:1174
ImRect::Overlaps
bool Overlaps(const ImRect &r) const
Definition: imgui_internal.h:461
ImGuiWindow::IDStack
ImVector< ImGuiID > IDStack
Definition: imgui_internal.h:1128
ImGuiContext::MouseCursor
ImGuiMouseCursor MouseCursor
Definition: imgui_internal.h:818
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
ImGuiContext::NextTreeNodeOpenCond
ImGuiCond NextTreeNodeOpenCond
Definition: imgui_internal.h:771
ImGuiContext::DragCurrentAccum
float DragCurrentAccum
Definition: imgui_internal.h:849
ImGuiColumnsFlags
int ImGuiColumnsFlags
Definition: imgui.h:133
ImGuiItemFlags_NoTabStop
Definition: imgui_internal.h:991
ImGuiContext::NextWindowData
ImGuiNextWindowData NextWindowData
Definition: imgui_internal.h:769
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
ImGuiWindow::Rect
ImRect Rect() const
Definition: imgui_internal.h:1172
ImTextCountCharsFromUtf8
IMGUI_API int ImTextCountCharsFromUtf8(const char *in_text, const char *in_text_end)
Definition: imgui.cpp:1609
ImGui::GetCurrentWindow
ImGuiWindow * GetCurrentWindow()
Definition: imgui_internal.h:1258
ImGuiButtonFlags_None
Definition: imgui_internal.h:277
ImLinearSweep
static float ImLinearSweep(float current, float target, float speed)
Definition: imgui_internal.h:236
ImRect::Floor
void Floor()
Definition: imgui_internal.h:471
ImGuiWindowTempData::StateStorage
ImGuiStorage * StateStorage
Definition: imgui_internal.h:1028
ImGuiCol
int ImGuiCol
Definition: imgui.h:120
ImGuiWindowTempData::ChildWindows
ImVector< ImGuiWindow * > ChildWindows
Definition: imgui_internal.h:1027
ImGuiDragFlags_None
Definition: imgui_internal.h:302
ImGuiInputReadMode_RepeatSlow
Definition: imgui_internal.h:387
ImGuiInputSource_NavKeyboard
Definition: imgui_internal.h:375
ImGuiWindow::OuterRectClipped
ImRect OuterRectClipped
Definition: imgui_internal.h:1130
ImGuiNavInput
int ImGuiNavInput
Definition: imgui.h:125
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
ImGuiWindowTempData::ColumnsSet
ImGuiColumnsSet * ColumnsSet
Definition: imgui_internal.h:1045
ImGuiColumnsFlags_NoPreserveWidths
Definition: imgui_internal.h:312
ImGuiItemHoveredDataBackup::LastItemStatusFlags
ImGuiItemStatusFlags LastItemStatusFlags
Definition: imgui_internal.h:1184
ImGuiDragFlags
int ImGuiDragFlags
Definition: imgui_internal.h:87
ImGuiNavHighlightFlags_AlwaysDraw
Definition: imgui_internal.h:396
ImGuiNextWindowData::SizeConstraintCond
ImGuiCond SizeConstraintCond
Definition: imgui_internal.h:672
ImGui::CalcItemSize
IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_x, float default_y)
Definition: imgui.cpp:2861
ImGuiNavMoveFlags_WrapY
Definition: imgui_internal.h:414
ImRect::Translate
void Translate(const ImVec2 &d)
Definition: imgui_internal.h:466
ImGui::FindSettingsHandler
IMGUI_API ImGuiSettingsHandler * FindSettingsHandler(const char *type_name)
Definition: imgui.cpp:8828
GImGui
IMGUI_API ImGuiContext * GImGui
Definition: imgui.cpp:1042
ImGui::GetFocusID
ImGuiID GetFocusID()
Definition: imgui_internal.h:1299
ImGuiWindowTempData::NavLayerCurrent
ImGuiNavLayer NavLayerCurrent
Definition: imgui_internal.h:1019
ImGuiPopupRef::Window
ImGuiWindow * Window
Definition: imgui_internal.h:578
ImGuiNavHighlightFlags
int ImGuiNavHighlightFlags
Definition: imgui_internal.h:82
ImGuiGroupData::BackupCursorMaxPos
ImVec2 BackupCursorMaxPos
Definition: imgui_internal.h:496
ImGuiWindow::SizeContents
ImVec2 SizeContents
Definition: imgui_internal.h:1089
ImGuiContext::WindowsById
ImGuiStorage WindowsById
Definition: imgui_internal.h:736
ImGui::IsKeyPressedMap
bool IsKeyPressedMap(ImGuiKey key, bool repeat=true)
Definition: imgui_internal.h:1347
ImVec1::ImVec1
ImVec1(float _x)
Definition: imgui_internal.h:272
ImVector::reserve
void reserve(int new_capacity)
Definition: imgui.h:1203
ImGuiContext::NextTreeNodeOpenVal
bool NextTreeNodeOpenVal
Definition: imgui_internal.h:770
ImGui::UpdateWindowParentAndRootLinks
IMGUI_API void UpdateWindowParentAndRootLinks(ImGuiWindow *window, ImGuiWindowFlags flags, ImGuiWindow *parent_window)
Definition: imgui.cpp:4717
ImGuiInputTextState::TempBuffer
ImVector< char > TempBuffer
Definition: imgui_internal.h:527
ImGui::ClearActiveID
IMGUI_API void ClearActiveID()
Definition: imgui.cpp:2617
ImGuiNavForward
ImGuiNavForward
Definition: imgui_internal.h:419
ImGuiButtonFlags_DontClosePopups
Definition: imgui_internal.h:285
ImGuiPopupPositionPolicy_ComboBox
Definition: imgui_internal.h:436
ImRect::Min
ImVec2 Min
Definition: imgui_internal.h:443
ImGuiContext::DragDropWithinSourceOrTarget
bool DragDropWithinSourceOrTarget
Definition: imgui_internal.h:822
ImRect::Contains
bool Contains(const ImVec2 &p) const
Definition: imgui_internal.h:459
ImParseFormatFindStart
IMGUI_API const char * ImParseFormatFindStart(const char *format)
Definition: imgui_widgets.cpp:2536
ImGuiIO::Fonts
ImFontAtlas * Fonts
Definition: imgui.h:1290
ImGuiIO::FontDefault
ImFont * FontDefault
Definition: imgui.h:1293
ImGui::NavMoveRequestForward
IMGUI_API void NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect &bb_rel, ImGuiNavMoveFlags move_flags)
Definition: imgui.cpp:7223
ImGuiContext::NavInputId
ImGuiID NavInputId
Definition: imgui_internal.h:779
ImGuiContext::HoveredWindow
ImGuiWindow * HoveredWindow
Definition: imgui_internal.h:739
ImGuiContext::DragDropAcceptIdCurr
ImGuiID DragDropAcceptIdCurr
Definition: imgui_internal.h:831
ImUpperPowerOfTwo
static int ImUpperPowerOfTwo(int v)
Definition: imgui_internal.h:150
ImGuiContext::NavDisableMouseHover
bool NavDisableMouseHover
Definition: imgui_internal.h:797
ImGuiItemFlags_Default_
Definition: imgui_internal.h:997
ImGuiContext::DragDropPayloadBufHeap
ImVector< unsigned char > DragDropPayloadBufHeap
Definition: imgui_internal.h:834
ImGui::BeginPopupEx
IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags)
Definition: imgui.cpp:6753
ImRect::Add
void Add(const ImVec2 &p)
Definition: imgui_internal.h:462
ImGui::IsClippedEx
IMGUI_API bool IsClippedEx(const ImRect &bb, ImGuiID id, bool clip_even_when_logged)
Definition: imgui.cpp:2819
ImGuiButtonFlags
int ImGuiButtonFlags
Definition: imgui_internal.h:79
ImGuiInputReadMode_Down
Definition: imgui_internal.h:383
ImGuiStyleMod::VarIdx
ImGuiStyleVar VarIdx
Definition: imgui_internal.h:485
ImGui::GetCurrentWindowRead
ImGuiWindow * GetCurrentWindowRead()
Definition: imgui_internal.h:1257
ImGui::IsNavInputDown
bool IsNavInputDown(ImGuiNavInput n)
Definition: imgui_internal.h:1348
ImGuiItemStatusFlags
int ImGuiItemStatusFlags
Definition: imgui_internal.h:81
ImGuiWindow::ScrollTarget
ImVec2 ScrollTarget
Definition: imgui_internal.h:1098
ImVec4::y
float y
Definition: imgui.h:178
ImGetDirQuadrantFromDelta
IMGUI_API ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy)
Definition: imgui.cpp:6979
ImVec2::x
float x
Definition: imgui.h:166
ImGuiContext::ActiveIdPreviousFrameHasBeenEdited
bool ActiveIdPreviousFrameHasBeenEdited
Definition: imgui_internal.h:754
ImGuiWindow::SetWindowSizeAllowFlags
ImGuiCond SetWindowSizeAllowFlags
Definition: imgui_internal.h:1122
operator-
b2Vec2 operator-(const b2Vec2 &a, const b2Vec2 &b)
Subtract two vectors component-wise.
Definition: b2_math.h:441
ImGuiWindow::MenuBarHeight
float MenuBarHeight() const
Definition: imgui_internal.h:1176
ImGuiInputTextState::TextW
ImVector< ImWchar > TextW
Definition: imgui_internal.h:525
ImMin
static T ImMin(T lhs, T rhs)
Definition: imgui_internal.h:216
ImPool::Remove
void Remove(ImGuiID key, ImPoolIdx idx)
Definition: imgui_internal.h:258
IM_PLACEMENT_NEW
#define IM_PLACEMENT_NEW(_PTR)
Definition: imgui.h:1523
ImPool::Remove
void Remove(ImGuiID key, const T *p)
Definition: imgui_internal.h:257
ImGuiContext::NavNextActivateId
ImGuiID NavNextActivateId
Definition: imgui_internal.h:782
ImGuiContext::ActiveIdSource
ImGuiInputSource ActiveIdSource
Definition: imgui_internal.h:759
ImGuiTabBarFlags_SaveSettings
Definition: imgui_internal.h:1202
ImGuiContext::NavJustMovedToId
ImGuiID NavJustMovedToId
Definition: imgui_internal.h:781
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
ImFormatStringV
IMGUI_API int ImFormatStringV(char *buf, size_t buf_size, const char *fmt, va_list args) IM_FMTLIST(3)
Definition: imgui.cpp:1405
IM_NEW
#define IM_NEW(_TYPE)
Definition: imgui.h:1524
ImGuiContext::NavWindowingHighlightAlpha
float NavWindowingHighlightAlpha
Definition: imgui_internal.h:790
ImGuiPopupPositionPolicy
ImGuiPopupPositionPolicy
Definition: imgui_internal.h:433
ImGuiNavMoveFlags_AllowCurrentNavId
Definition: imgui_internal.h:415

mvsim
Author(s):
autogenerated on Tue Jul 4 2023 03:08:21