1 // dear imgui, v1.68 WIP
2 // (internal structures/api)
4 // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
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)
13 // Forward declarations
14 // STB libraries includes
17 // Misc data structures
26 //-----------------------------------------------------------------------------
28 //-----------------------------------------------------------------------------
31 #error Must include imgui.h before imgui_internal.h
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
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)
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"
52 #if __has_warning("-Wdouble-promotion")
53 #pragma clang diagnostic ignored "-Wdouble-promotion"
57 //-----------------------------------------------------------------------------
58 // Forward declarations
59 //-----------------------------------------------------------------------------
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)
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()
95 //-------------------------------------------------------------------------
96 // STB libraries includes
97 //-------------------------------------------------------------------------
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"
109 } // namespace ImGuiStb
111 //-----------------------------------------------------------------------------
113 //-----------------------------------------------------------------------------
116 extern IMGUI_API ImGuiContext
* GImGui
; // Current implicit ImGui context pointer
119 //-----------------------------------------------------------------------------
121 //-----------------------------------------------------------------------------
123 #define IM_PI 3.14159265358979323846f
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!)
127 #define IM_NEWLINE "\n"
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
135 // Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
137 #define IMGUI_CDECL __cdecl
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
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]
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
);
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
);
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
); }
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
); }
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
); }
250 // Helper: ImBoolVector. Store 1-bit per value.
251 // Note that Resize() currently clears the whole vector.
254 ImVector
<int> Storage
;
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
; }
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
;
266 struct IMGUI_API ImPool
268 ImVector
<T
> Data
; // Contiguous data
269 ImGuiStorage Map
; // ID->Index
270 ImPoolIdx FreeIdx
; // Next free idx to use
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
; }
286 //-----------------------------------------------------------------------------
287 // Misc data structures
288 //-----------------------------------------------------------------------------
290 enum ImGuiButtonFlags_
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
309 enum ImGuiSliderFlags_
311 ImGuiSliderFlags_None
= 0,
312 ImGuiSliderFlags_Vertical
= 1 << 0
317 ImGuiDragFlags_None
= 0,
318 ImGuiDragFlags_Vertical
= 1 << 0
321 enum ImGuiColumnsFlags_
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.
332 enum ImGuiSelectableFlagsPrivate_
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
341 enum ImGuiSeparatorFlags_
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
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.
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
361 // Storage for LastItem data
362 enum ImGuiItemStatusFlags_
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)
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 //
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_
382 ImGuiLayoutType_Horizontal
= 0,
383 ImGuiLayoutType_Vertical
= 1
386 // X/Y enums are fixed to 0/1 so they may be used to index ImVec2
397 ImGuiPlotType_Histogram
400 enum ImGuiInputSource
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
410 // FIXME-NAV: Clarify/expose various repeat delay/rate
411 enum ImGuiInputReadMode
413 ImGuiInputReadMode_Down
,
414 ImGuiInputReadMode_Pressed
,
415 ImGuiInputReadMode_Released
,
416 ImGuiInputReadMode_Repeat
,
417 ImGuiInputReadMode_RepeatSlow
,
418 ImGuiInputReadMode_RepeatFast
421 enum ImGuiNavHighlightFlags_
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
430 enum ImGuiNavDirSourceFlags_
432 ImGuiNavDirSourceFlags_None
= 0,
433 ImGuiNavDirSourceFlags_Keyboard
= 1 << 0,
434 ImGuiNavDirSourceFlags_PadDPad
= 1 << 1,
435 ImGuiNavDirSourceFlags_PadLStick
= 1 << 2
438 enum ImGuiNavMoveFlags_
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.
451 ImGuiNavForward_None
,
452 ImGuiNavForward_ForwardQueued
,
453 ImGuiNavForward_ForwardActive
458 ImGuiNavLayer_Main
= 0, // Main scrolling layer
459 ImGuiNavLayer_Menu
= 1, // Menu layer (access with Alt/ImGuiNavInput_Menu)
463 enum ImGuiPopupPositionPolicy
465 ImGuiPopupPositionPolicy_Default
,
466 ImGuiPopupPositionPolicy_ComboBox
469 // 1D vector (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches)
473 ImVec1() { x
= 0.0f
; }
474 ImVec1(float _x
) { x
= _x
; }
478 // 2D axis aligned bounding-box
479 // NB: we can't rely on ImVec2 math operators being available here
480 struct IMGUI_API ImRect
482 ImVec2 Min
; // Upper-left
483 ImVec2 Max
; // Lower-right
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
) {}
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
; }
514 // Stacked color modifier, backup of modified data so we can restore it
521 // Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
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
; }
531 // Stacked storage data for BeginGroup()/EndGroup()
532 struct ImGuiGroupData
534 ImVec2 BackupCursorPos
;
535 ImVec2 BackupCursorMaxPos
;
537 ImVec1 BackupGroupOffset
;
538 ImVec2 BackupCurrentLineSize
;
539 float BackupCurrentLineTextBaseOffset
;
540 float BackupLogLinePosY
;
541 ImGuiID BackupActiveIdIsAlive
;
542 bool BackupActiveIdPreviousFrameIsAlive
;
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
551 float Width
, NextWidth
;
552 float Pos
[4], NextWidths
[4];
555 void Update(int count
, float spacing
, bool clear
);
556 float DeclColumns(float w0
, float w1
, float w2
);
557 float CalcExtraSpace(float avail_w
);
560 // Internal state of the currently focused/edited text input box
561 struct IMGUI_API ImGuiInputTextState
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
570 ImGuiStb::STB_TexteditState StbState
;
573 bool SelectedAllMouseLock
;
575 // Temporarily set when active
576 ImGuiInputTextFlags UserFlags
;
577 ImGuiInputTextCallback UserCallback
;
578 void* UserCallbackData
;
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
589 // Windows data saved in imgui.ini file
590 struct ImGuiWindowSettings
598 ImGuiWindowSettings() { Name
= NULL
; ID
= 0; Pos
= Size
= ImVec2(0,0); Collapsed
= false; }
601 struct ImGuiSettingsHandler
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'
610 ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
613 // Storage for current popup stack
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
625 struct ImGuiColumnData
627 float OffsetNorm
; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
628 float OffsetNormBeforeResize
;
629 ImGuiColumnsFlags Flags
; // Not exposed
632 ImGuiColumnData() { OffsetNorm
= OffsetNormBeforeResize
= 0.0f
; Flags
= 0; }
635 struct ImGuiColumnsSet
638 ImGuiColumnsFlags Flags
;
644 float LineMinY
, LineMaxY
;
645 float StartPosY
; // Copy of CursorPos
646 float StartMaxPosX
; // Copy of CursorMaxPos
647 ImVector
<ImGuiColumnData
> Columns
;
649 ImGuiColumnsSet() { Clear(); }
654 IsFirstFrame
= false;
655 IsBeingResized
= false;
659 LineMinY
= LineMaxY
= 0.0f
;
666 // Data shared between all ImDrawList instances
667 struct IMGUI_API ImDrawListSharedData
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()
676 // FIXME: Bake rounded corners fill/borders in atlas
677 ImVec2 CircleVtx12
[12];
679 ImDrawListSharedData();
682 struct ImDrawDataBuilder
684 ImVector
<ImDrawList
*> Layers
[2]; // Global layers for: regular, tooltip
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();
691 struct ImGuiNavMoveResult
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
699 ImRect RectRel
; // Best candidate bounding box in window relative space
701 ImGuiNavMoveResult() { Clear(); }
702 void Clear() { ID
= SelectScopeId
= 0; Window
= NULL
; DistBox
= DistCenter
= DistAxial
= FLT_MAX
; RectRel
= ImRect(); }
705 // Storage for SetNexWindow** functions
706 struct ImGuiNextWindowData
710 ImGuiCond ContentSizeCond
;
711 ImGuiCond CollapsedCond
;
712 ImGuiCond SizeConstraintCond
;
714 ImGuiCond BgAlphaCond
;
718 ImVec2 ContentSizeVal
;
720 ImRect SizeConstraintRect
;
721 ImGuiSizeCallback SizeCallback
;
722 void* SizeCallbackUserData
;
724 ImVec2 MenuBarOffsetMinVal
; // This is not exposed publicly, so we don't clear it.
726 ImGuiNextWindowData()
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();
734 SizeCallbackUserData
= NULL
;
735 BgAlphaVal
= FLT_MAX
;
736 MenuBarOffsetMinVal
= ImVec2(0.0f
, 0.0f
);
741 PosCond
= SizeCond
= ContentSizeCond
= CollapsedCond
= SizeConstraintCond
= FocusCond
= BgAlphaCond
= 0;
745 //-----------------------------------------------------------------------------
747 //-----------------------------------------------------------------------------
749 struct ImGuiTabBarSortItem
755 //-----------------------------------------------------------------------------
756 // Main imgui context
757 //-----------------------------------------------------------------------------
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.
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
;
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)
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
;
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)
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
;
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
885 ImPool
<ImGuiTabBar
> TabBars
;
886 ImVector
<ImGuiTabBar
*> CurrentTabBar
;
887 ImVector
<ImGuiTabBarSortItem
> TabSortByWidthBuffer
;
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
902 // Range-Select/Multi-Select
903 // [This is unused in this branch, but left here to facilitate merging/syncing multiple branches]
904 ImGuiID MultiSelectScopeId
;
907 ImVec2 PlatformImePos
; // Cursor position request & last passed to the OS Input Method Editor
908 ImVec2 PlatformImeLastPos
;
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)
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.
922 int LogAutoExpandMaxDepth
;
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
933 ImGuiContext(ImFontAtlas
* shared_font_atlas
) : OverlayDrawList(NULL
)
936 FrameScopeActive
= FrameScopePushedImplicitWindow
= false;
938 FontSize
= FontBaseSize
= 0.0f
;
939 FontAtlasOwnedByContext
= shared_font_atlas
? false : true;
940 IO
.Fonts
= shared_font_atlas
? shared_font_atlas
: IM_NEW(ImFontAtlas
)();
944 FrameCountEnded
= FrameCountRendered
= -1;
945 WindowsActiveCount
= 0;
946 CurrentWindow
= NULL
;
947 HoveredWindow
= NULL
;
948 HoveredRootWindow
= NULL
;
950 HoveredIdAllowOverlap
= false;
951 HoveredIdPreviousFrame
= 0;
952 HoveredIdTimer
= HoveredIdNotActiveTimer
= 0.0f
;
954 ActiveIdPreviousFrame
= 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
;
969 LastActiveIdTimer
= 0.0f
;
970 LastValidMousePos
= ImVec2(0.0f
, 0.0f
);
972 NextTreeNodeOpenVal
= false;
973 NextTreeNodeOpenCond
= 0;
976 NavId
= NavActivateId
= NavActivateDownId
= NavActivatePressedId
= NavInputId
= 0;
977 NavJustTabbedId
= NavJustMovedToId
= NavJustMovedToSelectScopeId
= NavNextActivateId
= 0;
978 NavInputSource
= ImGuiInputSource_None
;
979 NavScoringRectScreen
= ImRect();
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;
994 NavMoveFromClampedRefRect
= false;
995 NavMoveRequest
= false;
996 NavMoveRequestFlags
= 0;
997 NavMoveRequestForward
= ImGuiNavForward_None
;
998 NavMoveDir
= NavMoveDirLast
= NavMoveClipDir
= ImGuiDir_None
;
1001 OverlayDrawList
._Data
= &DrawListSharedData
;
1002 OverlayDrawList
._OwnerName
= "##Overlay"; // Give it a name for debugging
1003 MouseCursor
= ImGuiMouseCursor_Arrow
;
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
));
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;
1024 MultiSelectScopeId
= 0;
1026 PlatformImePos
= PlatformImeLastPos
= ImVec2(FLT_MAX
, FLT_MAX
);
1028 SettingsLoaded
= false;
1029 SettingsDirtyTimer
= 0.0f
;
1034 LogAutoExpandMaxDepth
= 2;
1036 memset(FramerateSecPerFrame
, 0, sizeof(FramerateSecPerFrame
));
1037 FramerateSecPerFrameIdx
= 0;
1038 FramerateSecPerFrameAccum
= 0.0f
;
1039 WantCaptureMouseNextFrame
= WantCaptureKeyboardNextFrame
= WantTextInputNextFrame
= -1;
1040 memset(TempBuffer
, 0, sizeof(TempBuffer
));
1044 //-----------------------------------------------------------------------------
1046 //-----------------------------------------------------------------------------
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
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
;
1062 ImU32 TreeDepthMayJumpToParentOnPop
; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31
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()
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
1090 ImVec1 Indent
; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
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
1095 ImGuiWindowTempData()
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
;
1102 TreeDepthMayJumpToParentOnPop
= 0x00;
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
;
1116 ItemFlags
= ImGuiItemFlags_Default_
;
1117 TextWrapPos
= -1.0f
;
1118 memset(StackSizesBackup
, 0, sizeof(StackSizesBackup
));
1120 Indent
= ImVec1(0.0f
);
1121 GroupOffset
= ImVec1(0.0f
);
1122 ColumnsOffset
= ImVec1(0.0f
);
1127 // Storage for one window
1128 struct IMGUI_API ImGuiWindow
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)
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
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.
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)
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.
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
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
; // "
1211 ImGuiWindow(ImGuiContext
* context
, const char* name
);
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
);
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()); }
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
1233 ImGuiItemStatusFlags LastItemStatusFlags
;
1234 ImRect LastItemRect
;
1235 ImRect LastItemDisplayRect
;
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
; }
1242 //-----------------------------------------------------------------------------
1243 // Tab bar, tab item
1244 //-----------------------------------------------------------------------------
1246 enum ImGuiTabBarFlagsPrivate_
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
1253 enum ImGuiTabItemFlagsPrivate_
1255 ImGuiTabItemFlags_NoCloseButton
= 1 << 20 // Store whether p_open is set or not, which we need to recompute WidthContents during layout.
1258 // Storage for one active tab item (sizeof() 26~32 bytes)
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
1270 ImGuiTabItem() { ID
= Flags
= 0; LastFrameVisible
= LastFrameSelected
= -1; NameOffset
= -1; Offset
= Width
= WidthContents
= 0.0f
; }
1273 // Storage for a tab bar (sizeof() 92~96 bytes)
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
;
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
;
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.
1299 int GetTabOrder(const ImGuiTabItem
* tab
) const { return Tabs
.index_from_ptr(tab
); }
1300 const char* GetTabName(const ImGuiTabItem
* tab
) const
1302 IM_ASSERT(tab
->NameOffset
!= -1 && tab
->NameOffset
< TabsNames
.Buf
.Size
);
1303 return TabsNames
.Buf
.Data
+ tab
->NameOffset
;
1307 //-----------------------------------------------------------------------------
1309 // No guarantee of forward compatibility here.
1310 //-----------------------------------------------------------------------------
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
);
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]; }
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().
1348 IMGUI_API
void UpdateHoveredWindowAndCaptureFlags();
1349 IMGUI_API
void StartMouseMovingWindow(ImGuiWindow
* window
);
1350 IMGUI_API
void UpdateMouseMovingWindowNewFrame();
1351 IMGUI_API
void UpdateMouseMovingWindowEndFrame();
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
);
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
);
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();
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
);
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
);
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
; }
1418 IMGUI_API
bool BeginDragDropTargetCustom(const ImRect
& bb
, ImGuiID id
);
1419 IMGUI_API
void ClearDragDrop();
1420 IMGUI_API
bool IsDragDropPayloadBeingAccepted();
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);
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
);
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
);
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
);
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.
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
);
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
);
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
);
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
);
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
);
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
);
1503 } // namespace ImGui
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
);
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
1523 #define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS) do { } while (0)
1527 #pragma clang diagnostic pop
1531 #pragma warning (pop)