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