1 // dear imgui, v1.63 WIP
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)
12 #error Must include imgui.h before imgui_internal.h
15 #include <stdio.h> // FILE*
16 #include <stdlib.h> // NULL, malloc, free, qsort, atoi, atof
17 #include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
18 #include <limits.h> // INT_MIN, INT_MAX
21 #pragma warning (push)
22 #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)
26 #pragma clang diagnostic push
27 #pragma clang diagnostic ignored "-Wunused-function" // for stb_textedit.h
28 #pragma clang diagnostic ignored "-Wmissing-prototypes" // for stb_textedit.h
29 #pragma clang diagnostic ignored "-Wold-style-cast"
32 //-----------------------------------------------------------------------------
33 // Forward Declarations
34 //-----------------------------------------------------------------------------
36 struct ImRect
; // An axis-aligned rectangle (2 points)
37 struct ImDrawDataBuilder
; // Helper to build a ImDrawData instance
38 struct ImDrawListSharedData
; // Data shared between all ImDrawList instances
39 struct ImGuiColMod
; // Stacked color modifier, backup of modified data so we can restore it
40 struct ImGuiColumnData
; // Storage data for a single column
41 struct ImGuiColumnsSet
; // Storage data for a columns set
42 struct ImGuiContext
; // Main imgui context
43 struct ImGuiGroupData
; // Stacked storage data for BeginGroup()/EndGroup()
44 struct ImGuiItemHoveredDataBackup
; // Backup and restore IsItemHovered() internal data
45 struct ImGuiMenuColumns
; // Simple column measurement, currently used for MenuItem() only
46 struct ImGuiNavMoveResult
; // Result of a directional navigation move query result
47 struct ImGuiNextWindowData
; // Storage for SetNexWindow** functions
48 struct ImGuiPopupRef
; // Storage for current popup stack
49 struct ImGuiSettingsHandler
;
50 struct ImGuiStyleMod
; // Stacked style modifier, backup of modified data so we can restore it
51 struct ImGuiTextEditState
; // Internal state of the currently focused/edited text input box
52 struct ImGuiWindow
; // Storage for one window
53 struct ImGuiWindowTempData
; // Temporary storage for one, that's the data which in theory we could ditch at the end of the frame
54 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)
56 typedef int ImGuiLayoutType
; // enum: horizontal or vertical // enum ImGuiLayoutType_
57 typedef int ImGuiButtonFlags
; // flags: for ButtonEx(), ButtonBehavior() // enum ImGuiButtonFlags_
58 typedef int ImGuiItemFlags
; // flags: for PushItemFlag() // enum ImGuiItemFlags_
59 typedef int ImGuiItemStatusFlags
; // flags: storage for DC.LastItemXXX // enum ImGuiItemStatusFlags_
60 typedef int ImGuiNavHighlightFlags
; // flags: for RenderNavHighlight() // enum ImGuiNavHighlightFlags_
61 typedef int ImGuiNavDirSourceFlags
; // flags: for GetNavInputAmount2d() // enum ImGuiNavDirSourceFlags_
62 typedef int ImGuiNavMoveFlags
; // flags: for navigation requests // enum ImGuiNavMoveFlags_
63 typedef int ImGuiSeparatorFlags
; // flags: for Separator() - internal // enum ImGuiSeparatorFlags_
64 typedef int ImGuiSliderFlags
; // flags: for SliderBehavior() // enum ImGuiSliderFlags_
66 //-------------------------------------------------------------------------
68 //-------------------------------------------------------------------------
73 #undef STB_TEXTEDIT_STRING
74 #undef STB_TEXTEDIT_CHARTYPE
75 #define STB_TEXTEDIT_STRING ImGuiTextEditState
76 #define STB_TEXTEDIT_CHARTYPE ImWchar
77 #define STB_TEXTEDIT_GETWIDTH_NEWLINE -1.0f
78 #include "stb_textedit.h"
80 } // namespace ImGuiStb
82 //-----------------------------------------------------------------------------
84 //-----------------------------------------------------------------------------
87 extern IMGUI_API ImGuiContext
* GImGui
; // Current implicit ImGui context pointer
90 //-----------------------------------------------------------------------------
92 //-----------------------------------------------------------------------------
94 #define IM_PI 3.14159265358979323846f
96 #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!)
98 #define IM_NEWLINE "\n"
101 // Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
103 #define IMGUI_CDECL __cdecl
108 // Helpers: UTF-8 <> wchar
109 IMGUI_API
int ImTextStrToUtf8(char* buf
, int buf_size
, const ImWchar
* in_text
, const ImWchar
* in_text_end
); // return output UTF-8 bytes count
110 IMGUI_API
int ImTextCharFromUtf8(unsigned int* out_char
, const char* in_text
, const char* in_text_end
); // return input UTF-8 bytes count
111 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
112 IMGUI_API
int ImTextCountCharsFromUtf8(const char* in_text
, const char* in_text_end
); // return number of UTF-8 code-points (NOT bytes count)
113 IMGUI_API
int ImTextCountUtf8BytesFromStr(const ImWchar
* in_text
, const ImWchar
* in_text_end
); // return number of bytes to express string as UTF-8 code-points
116 IMGUI_API ImU32
ImHash(const void* data
, int data_size
, ImU32 seed
= 0); // Pass data_size==0 for zero-terminated strings
117 IMGUI_API
void* ImFileLoadToMemory(const char* filename
, const char* file_open_mode
, size_t* out_file_size
= NULL
, int padding_bytes
= 0);
118 IMGUI_API
FILE* ImFileOpen(const char* filename
, const char* file_open_mode
);
119 static inline bool ImCharIsBlankA(char c
) { return c
== ' ' || c
== '\t'; }
120 static inline bool ImCharIsBlankW(unsigned int c
) { return c
== ' ' || c
== '\t' || c
== 0x3000; }
121 static inline bool ImIsPowerOfTwo(int v
) { return v
!= 0 && (v
& (v
- 1)) == 0; }
122 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
; }
123 #define ImQsort qsort
126 IMGUI_API ImVec2
ImLineClosestPoint(const ImVec2
& a
, const ImVec2
& b
, const ImVec2
& p
);
127 IMGUI_API
bool ImTriangleContainsPoint(const ImVec2
& a
, const ImVec2
& b
, const ImVec2
& c
, const ImVec2
& p
);
128 IMGUI_API ImVec2
ImTriangleClosestPoint(const ImVec2
& a
, const ImVec2
& b
, const ImVec2
& c
, const ImVec2
& p
);
129 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
);
132 IMGUI_API
int ImStricmp(const char* str1
, const char* str2
);
133 IMGUI_API
int ImStrnicmp(const char* str1
, const char* str2
, size_t count
);
134 IMGUI_API
void ImStrncpy(char* dst
, const char* src
, size_t count
);
135 IMGUI_API
char* ImStrdup(const char* str
);
136 IMGUI_API
const char* ImStrchrRange(const char* str_begin
, const char* str_end
, char c
);
137 IMGUI_API
int ImStrlenW(const ImWchar
* str
);
138 IMGUI_API
const ImWchar
*ImStrbolW(const ImWchar
* buf_mid_line
, const ImWchar
* buf_begin
); // Find beginning-of-line
139 IMGUI_API
const char* ImStristr(const char* haystack
, const char* haystack_end
, const char* needle
, const char* needle_end
);
140 IMGUI_API
void ImStrTrimBlanks(char* str
);
141 IMGUI_API
int ImFormatString(char* buf
, size_t buf_size
, const char* fmt
, ...) IM_FMTARGS(3);
142 IMGUI_API
int ImFormatStringV(char* buf
, size_t buf_size
, const char* fmt
, va_list args
) IM_FMTLIST(3);
143 IMGUI_API
const char* ImParseFormatFindStart(const char* format
);
144 IMGUI_API
const char* ImParseFormatFindEnd(const char* format
);
145 IMGUI_API
const char* ImParseFormatTrimDecorations(const char* format
, char* buf
, int buf_size
);
146 IMGUI_API
int ImParseFormatPrecision(const char* format
, int default_value
);
148 // Helpers: ImVec2/ImVec4 operators
149 // 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.)
150 // We unfortunately don't have a unary- operator for ImVec2 because this would needs to be defined inside the class itself.
151 #ifdef IMGUI_DEFINE_MATH_OPERATORS
152 static inline ImVec2
operator*(const ImVec2
& lhs
, const float rhs
) { return ImVec2(lhs
.x
*rhs
, lhs
.y
*rhs
); }
153 static inline ImVec2
operator/(const ImVec2
& lhs
, const float rhs
) { return ImVec2(lhs
.x
/rhs
, lhs
.y
/rhs
); }
154 static inline ImVec2
operator+(const ImVec2
& lhs
, const ImVec2
& rhs
) { return ImVec2(lhs
.x
+rhs
.x
, lhs
.y
+rhs
.y
); }
155 static inline ImVec2
operator-(const ImVec2
& lhs
, const ImVec2
& rhs
) { return ImVec2(lhs
.x
-rhs
.x
, lhs
.y
-rhs
.y
); }
156 static inline ImVec2
operator*(const ImVec2
& lhs
, const ImVec2
& rhs
) { return ImVec2(lhs
.x
*rhs
.x
, lhs
.y
*rhs
.y
); }
157 static inline ImVec2
operator/(const ImVec2
& lhs
, const ImVec2
& rhs
) { return ImVec2(lhs
.x
/rhs
.x
, lhs
.y
/rhs
.y
); }
158 static inline ImVec2
& operator+=(ImVec2
& lhs
, const ImVec2
& rhs
) { lhs
.x
+= rhs
.x
; lhs
.y
+= rhs
.y
; return lhs
; }
159 static inline ImVec2
& operator-=(ImVec2
& lhs
, const ImVec2
& rhs
) { lhs
.x
-= rhs
.x
; lhs
.y
-= rhs
.y
; return lhs
; }
160 static inline ImVec2
& operator*=(ImVec2
& lhs
, const float rhs
) { lhs
.x
*= rhs
; lhs
.y
*= rhs
; return lhs
; }
161 static inline ImVec2
& operator/=(ImVec2
& lhs
, const float rhs
) { lhs
.x
/= rhs
; lhs
.y
/= rhs
; return lhs
; }
162 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
); }
163 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
); }
164 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
); }
168 // - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)
169 #ifndef IMGUI_DISABLE_MATH_FUNCTIONS
170 static inline float ImFabs(float x
) { return fabsf(x
); }
171 static inline float ImSqrt(float x
) { return sqrtf(x
); }
172 static inline float ImPow(float x
, float y
) { return powf(x
, y
); }
173 static inline double ImPow(double x
, double y
) { return pow(x
, y
); }
174 static inline float ImFmod(float x
, float y
) { return fmodf(x
, y
); }
175 static inline double ImFmod(double x
, double y
) { return fmod(x
, y
); }
176 static inline float ImCos(float x
) { return cosf(x
); }
177 static inline float ImSin(float x
) { return sinf(x
); }
178 static inline float ImAcos(float x
) { return acosf(x
); }
179 static inline float ImAtan2(float y
, float x
) { return atan2f(y
, x
); }
180 static inline double ImAtof(const char* s
) { return atof(s
); }
181 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)
182 static inline float ImCeil(float x
) { return ceilf(x
); }
184 // - 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
185 template<typename T
> static inline T
ImMin(T lhs
, T rhs
) { return lhs
< rhs
? lhs
: rhs
; }
186 template<typename T
> static inline T
ImMax(T lhs
, T rhs
) { return lhs
>= rhs
? lhs
: rhs
; }
187 template<typename T
> static inline T
ImClamp(T v
, T mn
, T mx
) { return (v
< mn
) ? mn
: (v
> mx
) ? mx
: v
; }
188 template<typename T
> static inline T
ImLerp(T a
, T b
, float t
) { return (T
)(a
+ (b
- a
) * t
); }
189 template<typename T
> static inline void ImSwap(T
& a
, T
& b
) { T tmp
= a
; a
= b
; b
= tmp
; }
190 // - Misc maths helpers
191 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
); }
192 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
); }
193 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
); }
194 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
); }
195 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
); }
196 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
); }
197 static inline float ImSaturate(float f
) { return (f
< 0.0f
) ? 0.0f
: (f
> 1.0f
) ? 1.0f
: f
; }
198 static inline float ImLengthSqr(const ImVec2
& lhs
) { return lhs
.x
*lhs
.x
+ lhs
.y
*lhs
.y
; }
199 static inline float ImLengthSqr(const ImVec4
& lhs
) { return lhs
.x
*lhs
.x
+ lhs
.y
*lhs
.y
+ lhs
.z
*lhs
.z
+ lhs
.w
*lhs
.w
; }
200 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
; }
201 static inline float ImFloor(float f
) { return (float)(int)f
; }
202 static inline ImVec2
ImFloor(const ImVec2
& v
) { return ImVec2((float)(int)v
.x
, (float)(int)v
.y
); }
203 static inline float ImDot(const ImVec2
& a
, const ImVec2
& b
) { return a
.x
* b
.x
+ a
.y
* b
.y
; }
204 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
); }
205 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
; }
206 static inline ImVec2
ImMul(const ImVec2
& lhs
, const ImVec2
& rhs
) { return ImVec2(lhs
.x
* rhs
.x
, lhs
.y
* rhs
.y
); }
208 //-----------------------------------------------------------------------------
210 //-----------------------------------------------------------------------------
212 enum ImGuiButtonFlags_
214 ImGuiButtonFlags_None
= 0,
215 ImGuiButtonFlags_Repeat
= 1 << 0, // hold to repeat
216 ImGuiButtonFlags_PressedOnClickRelease
= 1 << 1, // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
217 ImGuiButtonFlags_PressedOnClick
= 1 << 2, // return true on click (default requires click+release)
218 ImGuiButtonFlags_PressedOnRelease
= 1 << 3, // return true on release (default requires click+release)
219 ImGuiButtonFlags_PressedOnDoubleClick
= 1 << 4, // return true on double-click (default requires click+release)
220 ImGuiButtonFlags_FlattenChildren
= 1 << 5, // allow interactions even if a child window is overlapping
221 ImGuiButtonFlags_AllowItemOverlap
= 1 << 6, // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
222 ImGuiButtonFlags_DontClosePopups
= 1 << 7, // disable automatically closing parent popup on press // [UNUSED]
223 ImGuiButtonFlags_Disabled
= 1 << 8, // disable interactions
224 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
225 ImGuiButtonFlags_NoKeyModifiers
= 1 << 10, // disable interaction if a key modifier is held
226 ImGuiButtonFlags_NoHoldingActiveID
= 1 << 11, // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
227 ImGuiButtonFlags_PressedOnDragDropHold
= 1 << 12, // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
228 ImGuiButtonFlags_NoNavFocus
= 1 << 13 // don't override navigation focus when activated
231 enum ImGuiSliderFlags_
233 ImGuiSliderFlags_None
= 0,
234 ImGuiSliderFlags_Vertical
= 1 << 0
237 enum ImGuiColumnsFlags_
240 ImGuiColumnsFlags_None
= 0,
241 ImGuiColumnsFlags_NoBorder
= 1 << 0, // Disable column dividers
242 ImGuiColumnsFlags_NoResize
= 1 << 1, // Disable resizing columns when clicking on the dividers
243 ImGuiColumnsFlags_NoPreserveWidths
= 1 << 2, // Disable column width preservation when adjusting columns
244 ImGuiColumnsFlags_NoForceWithinWindow
= 1 << 3, // Disable forcing columns to fit within window
245 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.
248 enum ImGuiSelectableFlagsPrivate_
250 // NB: need to be in sync with last value of ImGuiSelectableFlags_
251 ImGuiSelectableFlags_NoHoldingActiveID
= 1 << 10,
252 ImGuiSelectableFlags_PressedOnClick
= 1 << 11,
253 ImGuiSelectableFlags_PressedOnRelease
= 1 << 12,
254 ImGuiSelectableFlags_Disabled
= 1 << 13,
255 ImGuiSelectableFlags_DrawFillAvailWidth
= 1 << 14
258 enum ImGuiSeparatorFlags_
260 ImGuiSeparatorFlags_None
= 0,
261 ImGuiSeparatorFlags_Horizontal
= 1 << 0, // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
262 ImGuiSeparatorFlags_Vertical
= 1 << 1
265 // Storage for LastItem data
266 enum ImGuiItemStatusFlags_
268 ImGuiItemStatusFlags_None
= 0,
269 ImGuiItemStatusFlags_HoveredRect
= 1 << 0,
270 ImGuiItemStatusFlags_HasDisplayRect
= 1 << 1
273 // FIXME: this is in development, not exposed/functional as a generic feature yet.
274 enum ImGuiLayoutType_
276 ImGuiLayoutType_Vertical
,
277 ImGuiLayoutType_Horizontal
290 ImGuiPlotType_Histogram
293 enum ImGuiInputSource
295 ImGuiInputSource_None
= 0,
296 ImGuiInputSource_Mouse
,
297 ImGuiInputSource_Nav
,
298 ImGuiInputSource_NavKeyboard
, // Only used occasionally for storage, not tested/handled by most code
299 ImGuiInputSource_NavGamepad
, // "
300 ImGuiInputSource_COUNT
303 // FIXME-NAV: Clarify/expose various repeat delay/rate
304 enum ImGuiInputReadMode
306 ImGuiInputReadMode_Down
,
307 ImGuiInputReadMode_Pressed
,
308 ImGuiInputReadMode_Released
,
309 ImGuiInputReadMode_Repeat
,
310 ImGuiInputReadMode_RepeatSlow
,
311 ImGuiInputReadMode_RepeatFast
314 enum ImGuiNavHighlightFlags_
316 ImGuiNavHighlightFlags_TypeDefault
= 1 << 0,
317 ImGuiNavHighlightFlags_TypeThin
= 1 << 1,
318 ImGuiNavHighlightFlags_AlwaysDraw
= 1 << 2,
319 ImGuiNavHighlightFlags_NoRounding
= 1 << 3
322 enum ImGuiNavDirSourceFlags_
324 ImGuiNavDirSourceFlags_Keyboard
= 1 << 0,
325 ImGuiNavDirSourceFlags_PadDPad
= 1 << 1,
326 ImGuiNavDirSourceFlags_PadLStick
= 1 << 2
329 enum ImGuiNavMoveFlags_
331 ImGuiNavMoveFlags_LoopX
= 1 << 0, // On failed request, restart from opposite side
332 ImGuiNavMoveFlags_LoopY
= 1 << 1,
333 ImGuiNavMoveFlags_WrapX
= 1 << 2, // On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)
334 ImGuiNavMoveFlags_WrapY
= 1 << 3, // This is not super useful for provided for completeness
335 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)
336 ImGuiNavMoveFlags_AlsoScoreVisibleSet
= 1 << 5 // Store alternate result in NavMoveResultLocalVisibleSet that only comprise elements that are already fully visible.
341 ImGuiNavForward_None
,
342 ImGuiNavForward_ForwardQueued
,
343 ImGuiNavForward_ForwardActive
346 // 2D axis aligned bounding-box
347 // NB: we can't rely on ImVec2 math operators being available here
348 struct IMGUI_API ImRect
350 ImVec2 Min
; // Upper-left
351 ImVec2 Max
; // Lower-right
353 ImRect() : Min(FLT_MAX
,FLT_MAX
), Max(-FLT_MAX
,-FLT_MAX
) {}
354 ImRect(const ImVec2
& min
, const ImVec2
& max
) : Min(min
), Max(max
) {}
355 ImRect(const ImVec4
& v
) : Min(v
.x
, v
.y
), Max(v
.z
, v
.w
) {}
356 ImRect(float x1
, float y1
, float x2
, float y2
) : Min(x1
, y1
), Max(x2
, y2
) {}
358 ImVec2
GetCenter() const { return ImVec2((Min
.x
+ Max
.x
) * 0.5f
, (Min
.y
+ Max
.y
) * 0.5f
); }
359 ImVec2
GetSize() const { return ImVec2(Max
.x
- Min
.x
, Max
.y
- Min
.y
); }
360 float GetWidth() const { return Max
.x
- Min
.x
; }
361 float GetHeight() const { return Max
.y
- Min
.y
; }
362 ImVec2
GetTL() const { return Min
; } // Top-left
363 ImVec2
GetTR() const { return ImVec2(Max
.x
, Min
.y
); } // Top-right
364 ImVec2
GetBL() const { return ImVec2(Min
.x
, Max
.y
); } // Bottom-left
365 ImVec2
GetBR() const { return Max
; } // Bottom-right
366 bool Contains(const ImVec2
& p
) const { return p
.x
>= Min
.x
&& p
.y
>= Min
.y
&& p
.x
< Max
.x
&& p
.y
< Max
.y
; }
367 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
; }
368 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
; }
369 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
; }
370 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
; }
371 void Expand(const float amount
) { Min
.x
-= amount
; Min
.y
-= amount
; Max
.x
+= amount
; Max
.y
+= amount
; }
372 void Expand(const ImVec2
& amount
) { Min
.x
-= amount
.x
; Min
.y
-= amount
.y
; Max
.x
+= amount
.x
; Max
.y
+= amount
.y
; }
373 void Translate(const ImVec2
& d
) { Min
.x
+= d
.x
; Min
.y
+= d
.y
; Max
.x
+= d
.x
; Max
.y
+= d
.y
; }
374 void TranslateX(float dx
) { Min
.x
+= dx
; Max
.x
+= dx
; }
375 void TranslateY(float dy
) { Min
.y
+= dy
; Max
.y
+= dy
; }
376 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.
377 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.
378 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
; }
379 bool IsInverted() const { return Min
.x
> Max
.x
|| Min
.y
> Max
.y
; }
382 // Stacked color modifier, backup of modified data so we can restore it
389 // Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
392 ImGuiStyleVar VarIdx
;
393 union { int BackupInt
[2]; float BackupFloat
[2]; };
394 ImGuiStyleMod(ImGuiStyleVar idx
, int v
) { VarIdx
= idx
; BackupInt
[0] = v
; }
395 ImGuiStyleMod(ImGuiStyleVar idx
, float v
) { VarIdx
= idx
; BackupFloat
[0] = v
; }
396 ImGuiStyleMod(ImGuiStyleVar idx
, ImVec2 v
) { VarIdx
= idx
; BackupFloat
[0] = v
.x
; BackupFloat
[1] = v
.y
; }
399 // Stacked storage data for BeginGroup()/EndGroup()
400 struct ImGuiGroupData
402 ImVec2 BackupCursorPos
;
403 ImVec2 BackupCursorMaxPos
;
405 float BackupGroupOffsetX
;
406 float BackupCurrentLineHeight
;
407 float BackupCurrentLineTextBaseOffset
;
408 float BackupLogLinePosY
;
409 bool BackupActiveIdIsAlive
;
410 bool BackupActiveIdPreviousFrameIsAlive
;
414 // Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper.
415 struct IMGUI_API ImGuiMenuColumns
419 float Width
, NextWidth
;
420 float Pos
[4], NextWidths
[4];
423 void Update(int count
, float spacing
, bool clear
);
424 float DeclColumns(float w0
, float w1
, float w2
);
425 float CalcExtraSpace(float avail_w
);
428 // Internal state of the currently focused/edited text input box
429 struct IMGUI_API ImGuiTextEditState
431 ImGuiID Id
; // widget id owning the text state
432 ImVector
<ImWchar
> Text
; // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
433 ImVector
<char> InitialText
; // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
434 ImVector
<char> TempTextBuffer
;
435 int CurLenA
, CurLenW
; // we need to maintain our buffer length in both UTF-8 and wchar format.
436 int BufSizeA
; // end-user buffer size
438 ImGuiStb::STB_TexteditState StbState
;
441 bool SelectedAllMouseLock
;
443 ImGuiTextEditState() { memset(this, 0, sizeof(*this)); }
444 void CursorAnimReset() { CursorAnim
= -0.30f
; } // After a user-input the cursor stays on for a while without blinking
445 void CursorClamp() { StbState
.cursor
= ImMin(StbState
.cursor
, CurLenW
); StbState
.select_start
= ImMin(StbState
.select_start
, CurLenW
); StbState
.select_end
= ImMin(StbState
.select_end
, CurLenW
); }
446 bool HasSelection() const { return StbState
.select_start
!= StbState
.select_end
; }
447 void ClearSelection() { StbState
.select_start
= StbState
.select_end
= StbState
.cursor
; }
448 void SelectAll() { StbState
.select_start
= 0; StbState
.cursor
= StbState
.select_end
= CurLenW
; StbState
.has_preferred_x
= false; }
449 void OnKeyPressed(int key
);
452 // Windows data saved in imgui.ini file
453 struct ImGuiWindowSettings
461 ImGuiWindowSettings() { Name
= NULL
; ID
= 0; Pos
= Size
= ImVec2(0,0); Collapsed
= false; }
464 struct ImGuiSettingsHandler
466 const char* TypeName
; // Short description stored in .ini file. Disallowed characters: '[' ']'
467 ImGuiID TypeHash
; // == ImHash(TypeName, 0, 0)
468 void* (*ReadOpenFn
)(ImGuiContext
* ctx
, ImGuiSettingsHandler
* handler
, const char* name
); // Read: Called when entering into a new ini entry e.g. "[Window][Name]"
469 void (*ReadLineFn
)(ImGuiContext
* ctx
, ImGuiSettingsHandler
* handler
, void* entry
, const char* line
); // Read: Called for every line of text within an ini entry
470 void (*WriteAllFn
)(ImGuiContext
* ctx
, ImGuiSettingsHandler
* handler
, ImGuiTextBuffer
* out_buf
); // Write: Output every entries into 'out_buf'
473 ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
476 // Storage for current popup stack
479 ImGuiID PopupId
; // Set on OpenPopup()
480 ImGuiWindow
* Window
; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
481 ImGuiWindow
* ParentWindow
; // Set on OpenPopup()
482 int OpenFrameCount
; // Set on OpenPopup()
483 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)
484 ImVec2 OpenPopupPos
; // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
485 ImVec2 OpenMousePos
; // Set on OpenPopup(), copy of mouse position at the time of opening popup
488 struct ImGuiColumnData
490 float OffsetNorm
; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
491 float OffsetNormBeforeResize
;
492 ImGuiColumnsFlags Flags
; // Not exposed
495 ImGuiColumnData() { OffsetNorm
= OffsetNormBeforeResize
= 0.0f
; Flags
= 0; }
498 struct ImGuiColumnsSet
501 ImGuiColumnsFlags Flags
;
507 float LineMinY
, LineMaxY
;
508 float StartPosY
; // Copy of CursorPos
509 float StartMaxPosX
; // Copy of CursorMaxPos
510 ImVector
<ImGuiColumnData
> Columns
;
512 ImGuiColumnsSet() { Clear(); }
517 IsFirstFrame
= false;
518 IsBeingResized
= false;
522 LineMinY
= LineMaxY
= 0.0f
;
529 // Data shared between all ImDrawList instances
530 struct IMGUI_API ImDrawListSharedData
532 ImVec2 TexUvWhitePixel
; // UV of white pixel in the atlas
533 ImFont
* Font
; // Current/default font (optional, for simplified AddText overload)
534 float FontSize
; // Current/default font size (optional, for simplified AddText overload)
535 float CurveTessellationTol
;
536 ImVec4 ClipRectFullscreen
; // Value for PushClipRectFullscreen()
539 // FIXME: Bake rounded corners fill/borders in atlas
540 ImVec2 CircleVtx12
[12];
542 ImDrawListSharedData();
545 struct ImDrawDataBuilder
547 ImVector
<ImDrawList
*> Layers
[2]; // Global layers for: regular, tooltip
549 void Clear() { for (int n
= 0; n
< IM_ARRAYSIZE(Layers
); n
++) Layers
[n
].resize(0); }
550 void ClearFreeMemory() { for (int n
= 0; n
< IM_ARRAYSIZE(Layers
); n
++) Layers
[n
].clear(); }
551 IMGUI_API
void FlattenIntoSingleLayer();
554 struct ImGuiNavMoveResult
556 ImGuiID ID
; // Best candidate
557 ImGuiWindow
* Window
; // Best candidate window
558 float DistBox
; // Best candidate box distance to current NavId
559 float DistCenter
; // Best candidate center distance to current NavId
561 ImRect RectRel
; // Best candidate bounding box in window relative space
563 ImGuiNavMoveResult() { Clear(); }
564 void Clear() { ID
= 0; Window
= NULL
; DistBox
= DistCenter
= DistAxial
= FLT_MAX
; RectRel
= ImRect(); }
567 // Storage for SetNexWindow** functions
568 struct ImGuiNextWindowData
572 ImGuiCond ContentSizeCond
;
573 ImGuiCond CollapsedCond
;
574 ImGuiCond SizeConstraintCond
;
576 ImGuiCond BgAlphaCond
;
580 ImVec2 ContentSizeVal
;
582 ImRect SizeConstraintRect
;
583 ImGuiSizeCallback SizeCallback
;
584 void* SizeCallbackUserData
;
586 ImVec2 MenuBarOffsetMinVal
; // This is not exposed publicly, so we don't clear it.
588 ImGuiNextWindowData()
590 PosCond
= SizeCond
= ContentSizeCond
= CollapsedCond
= SizeConstraintCond
= FocusCond
= BgAlphaCond
= 0;
591 PosVal
= PosPivotVal
= SizeVal
= ImVec2(0.0f
, 0.0f
);
592 ContentSizeVal
= ImVec2(0.0f
, 0.0f
);
593 CollapsedVal
= false;
594 SizeConstraintRect
= ImRect();
596 SizeCallbackUserData
= NULL
;
597 BgAlphaVal
= FLT_MAX
;
598 MenuBarOffsetMinVal
= ImVec2(0.0f
, 0.0f
);
603 PosCond
= SizeCond
= ContentSizeCond
= CollapsedCond
= SizeConstraintCond
= FocusCond
= BgAlphaCond
= 0;
607 // Main imgui context
611 bool FontAtlasOwnedByContext
; // Io.Fonts-> is owned by the ImGuiContext and will be destructed along with it.
614 ImFont
* Font
; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
615 float FontSize
; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
616 float FontBaseSize
; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
617 ImDrawListSharedData DrawListSharedData
;
622 int FrameCountRendered
;
623 ImVector
<ImGuiWindow
*> Windows
;
624 ImVector
<ImGuiWindow
*> WindowsSortBuffer
;
625 ImVector
<ImGuiWindow
*> CurrentWindowStack
;
626 ImGuiStorage WindowsById
;
627 int WindowsActiveCount
;
628 ImGuiWindow
* CurrentWindow
; // Being drawn into
629 ImGuiWindow
* HoveredWindow
; // Will catch mouse inputs
630 ImGuiWindow
* HoveredRootWindow
; // Will catch mouse inputs (for focus/move only)
631 ImGuiID HoveredId
; // Hovered widget
632 bool HoveredIdAllowOverlap
;
633 ImGuiID HoveredIdPreviousFrame
;
634 float HoveredIdTimer
;
635 ImGuiID ActiveId
; // Active widget
636 ImGuiID ActiveIdPreviousFrame
;
638 bool ActiveIdIsAlive
; // Active widget has been seen this frame
639 bool ActiveIdIsJustActivated
; // Set at the time of activation for one frame
640 bool ActiveIdAllowOverlap
; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
641 bool ActiveIdValueChanged
;
642 bool ActiveIdPreviousFrameIsAlive
;
643 bool ActiveIdPreviousFrameValueChanged
;
644 int ActiveIdAllowNavDirFlags
; // Active widget allows using directional navigation (e.g. can activate a button and move away from it)
645 ImVec2 ActiveIdClickOffset
; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
646 ImGuiWindow
* ActiveIdWindow
;
647 ImGuiWindow
* ActiveIdPreviousFrameWindow
;
648 ImGuiInputSource ActiveIdSource
; // Activating with mouse or nav (gamepad/keyboard)
649 ImGuiID LastActiveId
; // Store the last non-zero ActiveId, useful for animation.
650 float LastActiveIdTimer
; // Store the last non-zero ActiveId timer since the beginning of activation, useful for animation.
651 ImGuiWindow
* MovingWindow
; // Track the window we clicked on (in order to preserve focus). The actually window that is moved is generally MovingWindow->RootWindow.
652 ImVector
<ImGuiColMod
> ColorModifiers
; // Stack for PushStyleColor()/PopStyleColor()
653 ImVector
<ImGuiStyleMod
> StyleModifiers
; // Stack for PushStyleVar()/PopStyleVar()
654 ImVector
<ImFont
*> FontStack
; // Stack for PushFont()/PopFont()
655 ImVector
<ImGuiPopupRef
> OpenPopupStack
; // Which popups are open (persistent)
656 ImVector
<ImGuiPopupRef
> CurrentPopupStack
; // Which level of BeginPopup() we are in (reset every frame)
657 ImGuiNextWindowData NextWindowData
; // Storage for SetNextWindow** functions
658 bool NextTreeNodeOpenVal
; // Storage for SetNextTreeNode** functions
659 ImGuiCond NextTreeNodeOpenCond
;
661 // Navigation data (for gamepad/keyboard)
662 ImGuiWindow
* NavWindow
; // Focused window for navigation. Could be called 'FocusWindow'
663 ImGuiID NavId
; // Focused item for navigation
664 ImGuiID NavActivateId
; // ~~ (g.ActiveId == 0) && IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0, also set when calling ActivateItem()
665 ImGuiID NavActivateDownId
; // ~~ IsNavInputDown(ImGuiNavInput_Activate) ? NavId : 0
666 ImGuiID NavActivatePressedId
; // ~~ IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0
667 ImGuiID NavInputId
; // ~~ IsNavInputPressed(ImGuiNavInput_Input) ? NavId : 0
668 ImGuiID NavJustTabbedId
; // Just tabbed to this id.
669 ImGuiID NavJustMovedToId
; // Just navigated to this id (result of a successfully MoveRequest)
670 ImGuiID NavNextActivateId
; // Set by ActivateItem(), queued until next frame
671 ImGuiInputSource NavInputSource
; // Keyboard or Gamepad mode?
672 ImRect NavScoringRectScreen
; // Rectangle used for scoring, in screen space. Based of window->DC.NavRefRectRel[], modified for directional navigation scoring.
673 int NavScoringCount
; // Metrics for debugging
674 ImGuiWindow
* NavWindowingTarget
; // When selecting a window (holding Menu+FocusPrev/Next, or equivalent of CTRL-TAB) this window is temporarily displayed front-most.
675 ImGuiWindow
* NavWindowingTargetAnim
; // Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f
676 ImGuiWindow
* NavWindowingList
;
677 float NavWindowingTimer
;
678 float NavWindowingHighlightAlpha
;
679 bool NavWindowingToggleLayer
;
680 int 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.
681 int NavIdTabCounter
; // == NavWindow->DC.FocusIdxTabCounter at time of NavId processing
682 bool NavIdIsAlive
; // Nav widget has been seen this frame ~~ NavRefRectRel is valid
683 bool NavMousePosDirty
; // When set we will update mouse position if (io.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos) if set (NB: this not enabled by default)
684 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)
685 bool NavDisableMouseHover
; // When user starts using gamepad/keyboard, we hide mouse hovering highlight until mouse is touched again.
686 bool NavAnyRequest
; // ~~ NavMoveRequest || NavInitRequest
687 bool NavInitRequest
; // Init request for appearing window to select first item
688 bool NavInitRequestFromMove
;
689 ImGuiID NavInitResultId
;
690 ImRect NavInitResultRectRel
;
691 bool NavMoveFromClampedRefRect
; // Set by manual scrolling, if we scroll to a point where NavId isn't visible we reset navigation from visible items
692 bool NavMoveRequest
; // Move request for this frame
693 ImGuiNavMoveFlags NavMoveRequestFlags
;
694 ImGuiNavForward NavMoveRequestForward
; // None / ForwardQueued / ForwardActive (this is used to navigate sibling parent menus from a child menu)
695 ImGuiDir NavMoveDir
, NavMoveDirLast
; // Direction of the move request (left/right/up/down), direction of the previous move request
696 ImGuiDir NavMoveClipDir
;
697 ImGuiNavMoveResult NavMoveResultLocal
; // Best move request candidate within NavWindow
698 ImGuiNavMoveResult NavMoveResultLocalVisibleSet
; // Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag)
699 ImGuiNavMoveResult NavMoveResultOther
; // Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag)
702 ImDrawData DrawData
; // Main ImDrawData instance to pass render information to the user
703 ImDrawDataBuilder DrawDataBuilder
;
704 float DimBgRatio
; // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)
705 ImDrawList OverlayDrawList
; // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays
706 ImGuiMouseCursor MouseCursor
;
710 bool DragDropWithinSourceOrTarget
;
711 ImGuiDragDropFlags DragDropSourceFlags
;
712 int DragDropMouseButton
;
713 ImGuiPayload DragDropPayload
;
714 ImRect DragDropTargetRect
;
715 ImGuiID DragDropTargetId
;
716 ImGuiDragDropFlags DragDropAcceptFlags
;
717 float DragDropAcceptIdCurrRectSurface
; // Target item surface (we resolve overlapping targets by prioritizing the smaller surface)
718 ImGuiID DragDropAcceptIdCurr
; // Target item id (set at the time of accepting the payload)
719 ImGuiID DragDropAcceptIdPrev
; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
720 int DragDropAcceptFrameCount
; // Last time a target expressed a desire to accept the source
721 ImVector
<unsigned char> DragDropPayloadBufHeap
; // We don't expose the ImVector<> directly
722 unsigned char DragDropPayloadBufLocal
[8]; // Local buffer for small payloads
725 ImGuiTextEditState InputTextState
;
726 ImFont InputTextPasswordFont
;
727 ImGuiID ScalarAsInputTextId
; // Temporary text input when CTRL+clicking on a slider, etc.
728 ImGuiColorEditFlags ColorEditOptions
; // Store user options for color edit widgets
729 ImVec4 ColorPickerRef
;
730 bool DragCurrentAccumDirty
;
731 float DragCurrentAccum
; // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings
732 float DragSpeedDefaultRatio
; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
733 ImVec2 ScrollbarClickDeltaToGrabCenter
; // Distance between mouse and center of grab box, normalized in parent space. Use storage?
734 int TooltipOverrideCount
;
735 ImVector
<char> PrivateClipboard
; // If no custom clipboard handler is defined
736 ImVec2 PlatformImePos
, PlatformImeLastPos
; // Cursor position request & last passed to the OS Input Method Editor
740 float SettingsDirtyTimer
; // Save .ini Settings to memory when time reaches zero
741 ImGuiTextBuffer SettingsIniData
; // In memory .ini settings
742 ImVector
<ImGuiSettingsHandler
> SettingsHandlers
; // List of .ini settings handlers
743 ImVector
<ImGuiWindowSettings
> SettingsWindows
; // ImGuiWindow .ini settings entries (parsed from the last loaded .ini file and maintained on saving)
747 FILE* LogFile
; // If != NULL log to stdout/ file
748 ImGuiTextBuffer LogClipboard
; // Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
750 int LogAutoExpandMaxDepth
;
753 float FramerateSecPerFrame
[120]; // Calculate estimate of framerate for user over the last 2 seconds.
754 int FramerateSecPerFrameIdx
;
755 float FramerateSecPerFrameAccum
;
756 int WantCaptureMouseNextFrame
; // Explicit capture via CaptureKeyboardFromApp()/CaptureMouseFromApp() sets those flags
757 int WantCaptureKeyboardNextFrame
;
758 int WantTextInputNextFrame
;
759 char TempBuffer
[1024*3+1]; // Temporary text buffer
761 ImGuiContext(ImFontAtlas
* shared_font_atlas
) : OverlayDrawList(NULL
)
765 FontSize
= FontBaseSize
= 0.0f
;
766 FontAtlasOwnedByContext
= shared_font_atlas
? false : true;
767 IO
.Fonts
= shared_font_atlas
? shared_font_atlas
: IM_NEW(ImFontAtlas
)();
771 FrameCountEnded
= FrameCountRendered
= -1;
772 WindowsActiveCount
= 0;
773 CurrentWindow
= NULL
;
774 HoveredWindow
= NULL
;
775 HoveredRootWindow
= NULL
;
777 HoveredIdAllowOverlap
= false;
778 HoveredIdPreviousFrame
= 0;
779 HoveredIdTimer
= 0.0f
;
781 ActiveIdPreviousFrame
= 0;
782 ActiveIdTimer
= 0.0f
;
783 ActiveIdIsAlive
= false;
784 ActiveIdIsJustActivated
= false;
785 ActiveIdAllowOverlap
= false;
786 ActiveIdValueChanged
= false;
787 ActiveIdPreviousFrameIsAlive
= false;
788 ActiveIdPreviousFrameValueChanged
= false;
789 ActiveIdAllowNavDirFlags
= 0;
790 ActiveIdClickOffset
= ImVec2(-1,-1);
791 ActiveIdWindow
= ActiveIdPreviousFrameWindow
= NULL
;
792 ActiveIdSource
= ImGuiInputSource_None
;
794 LastActiveIdTimer
= 0.0f
;
796 NextTreeNodeOpenVal
= false;
797 NextTreeNodeOpenCond
= 0;
800 NavId
= NavActivateId
= NavActivateDownId
= NavActivatePressedId
= NavInputId
= 0;
801 NavJustTabbedId
= NavJustMovedToId
= NavNextActivateId
= 0;
802 NavInputSource
= ImGuiInputSource_None
;
803 NavScoringRectScreen
= ImRect();
805 NavWindowingTarget
= NavWindowingTargetAnim
= NavWindowingList
= NULL
;
806 NavWindowingTimer
= NavWindowingHighlightAlpha
= 0.0f
;
807 NavWindowingToggleLayer
= false;
809 NavIdTabCounter
= INT_MAX
;
810 NavIdIsAlive
= false;
811 NavMousePosDirty
= false;
812 NavDisableHighlight
= true;
813 NavDisableMouseHover
= false;
814 NavAnyRequest
= false;
815 NavInitRequest
= false;
816 NavInitRequestFromMove
= false;
818 NavMoveFromClampedRefRect
= false;
819 NavMoveRequest
= false;
820 NavMoveRequestFlags
= 0;
821 NavMoveRequestForward
= ImGuiNavForward_None
;
822 NavMoveDir
= NavMoveDirLast
= NavMoveClipDir
= ImGuiDir_None
;
825 OverlayDrawList
._Data
= &DrawListSharedData
;
826 OverlayDrawList
._OwnerName
= "##Overlay"; // Give it a name for debugging
827 MouseCursor
= ImGuiMouseCursor_Arrow
;
829 DragDropActive
= DragDropWithinSourceOrTarget
= false;
830 DragDropSourceFlags
= 0;
831 DragDropMouseButton
= -1;
832 DragDropTargetId
= 0;
833 DragDropAcceptFlags
= 0;
834 DragDropAcceptIdCurrRectSurface
= 0.0f
;
835 DragDropAcceptIdPrev
= DragDropAcceptIdCurr
= 0;
836 DragDropAcceptFrameCount
= -1;
837 memset(DragDropPayloadBufLocal
, 0, sizeof(DragDropPayloadBufLocal
));
839 ScalarAsInputTextId
= 0;
840 ColorEditOptions
= ImGuiColorEditFlags__OptionsDefault
;
841 DragCurrentAccumDirty
= false;
842 DragCurrentAccum
= 0.0f
;
843 DragSpeedDefaultRatio
= 1.0f
/ 100.0f
;
844 ScrollbarClickDeltaToGrabCenter
= ImVec2(0.0f
, 0.0f
);
845 TooltipOverrideCount
= 0;
846 PlatformImePos
= PlatformImeLastPos
= ImVec2(FLT_MAX
, FLT_MAX
);
848 SettingsLoaded
= false;
849 SettingsDirtyTimer
= 0.0f
;
854 LogAutoExpandMaxDepth
= 2;
856 memset(FramerateSecPerFrame
, 0, sizeof(FramerateSecPerFrame
));
857 FramerateSecPerFrameIdx
= 0;
858 FramerateSecPerFrameAccum
= 0.0f
;
859 WantCaptureMouseNextFrame
= WantCaptureKeyboardNextFrame
= WantTextInputNextFrame
= -1;
860 memset(TempBuffer
, 0, sizeof(TempBuffer
));
864 // Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
865 // This is going to be exposed in imgui.h when stabilized enough.
868 ImGuiItemFlags_AllowKeyboardFocus
= 1 << 0, // true
869 ImGuiItemFlags_ButtonRepeat
= 1 << 1, // false // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
870 ImGuiItemFlags_Disabled
= 1 << 2, // false // [BETA] Disable interactions but doesn't affect visuals yet. See github.com/ocornut/imgui/issues/211
871 ImGuiItemFlags_NoNav
= 1 << 3, // false
872 ImGuiItemFlags_NoNavDefaultFocus
= 1 << 4, // false
873 ImGuiItemFlags_SelectableDontClosePopup
= 1 << 5, // false // MenuItem/Selectable() automatically closes current Popup window
874 ImGuiItemFlags_Default_
= ImGuiItemFlags_AllowKeyboardFocus
877 // Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow.
878 // FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered.
879 struct IMGUI_API ImGuiWindowTempData
882 ImVec2 CursorPosPrevLine
;
883 ImVec2 CursorStartPos
;
884 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
885 float CurrentLineHeight
;
886 float CurrentLineTextBaseOffset
;
887 float PrevLineHeight
;
888 float PrevLineTextBaseOffset
;
891 ImU32 TreeDepthMayJumpToParentOnPop
; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31
893 ImGuiItemStatusFlags LastItemStatusFlags
;
894 ImRect LastItemRect
; // Interaction rect
895 ImRect LastItemDisplayRect
; // End-user display rect (only valid if LastItemStatusFlags & ImGuiItemStatusFlags_HasDisplayRect)
896 bool NavHideHighlightOneFrame
;
897 bool NavHasScroll
; // Set when scrolling can be used (ScrollMax > 0.0f)
898 int NavLayerCurrent
; // Current layer, 0..31 (we currently only use 0..1)
899 int NavLayerCurrentMask
; // = (1 << NavLayerCurrent) used by ItemAdd prior to clipping.
900 int NavLayerActiveMask
; // Which layer have been written to (result from previous frame)
901 int NavLayerActiveMaskNext
; // Which layer have been written to (buffer for current frame)
902 bool MenuBarAppending
; // FIXME: Remove this
903 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.
904 ImVector
<ImGuiWindow
*> ChildWindows
;
905 ImGuiStorage
* StateStorage
;
906 ImGuiLayoutType LayoutType
;
907 ImGuiLayoutType ParentLayoutType
; // Layout type of parent window at the time of Begin()
909 // 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.
910 ImGuiItemFlags ItemFlags
; // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default]
911 float ItemWidth
; // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
912 float TextWrapPos
; // == TextWrapPosStack.back() [empty == -1.0f]
913 ImVector
<ImGuiItemFlags
>ItemFlagsStack
;
914 ImVector
<float> ItemWidthStack
;
915 ImVector
<float> TextWrapPosStack
;
916 ImVector
<ImGuiGroupData
>GroupStack
;
917 int StackSizesBackup
[6]; // Store size of various stacks for asserting
919 float IndentX
; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
921 float ColumnsOffsetX
; // 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.
922 ImGuiColumnsSet
* ColumnsSet
; // Current columns set
924 ImGuiWindowTempData()
926 CursorPos
= CursorPosPrevLine
= CursorStartPos
= CursorMaxPos
= ImVec2(0.0f
, 0.0f
);
927 CurrentLineHeight
= PrevLineHeight
= 0.0f
;
928 CurrentLineTextBaseOffset
= PrevLineTextBaseOffset
= 0.0f
;
931 TreeDepthMayJumpToParentOnPop
= 0x00;
933 LastItemStatusFlags
= 0;
934 LastItemRect
= LastItemDisplayRect
= ImRect();
935 NavHideHighlightOneFrame
= false;
936 NavHasScroll
= false;
937 NavLayerActiveMask
= NavLayerActiveMaskNext
= 0x00;
939 NavLayerCurrentMask
= 1 << 0;
940 MenuBarAppending
= false;
941 MenuBarOffset
= ImVec2(0.0f
, 0.0f
);
943 LayoutType
= ParentLayoutType
= ImGuiLayoutType_Vertical
;
945 ItemFlags
= ImGuiItemFlags_Default_
;
947 memset(StackSizesBackup
, 0, sizeof(StackSizesBackup
));
951 ColumnsOffsetX
= 0.0f
;
956 // Storage for one window
957 struct IMGUI_API ImGuiWindow
960 ImGuiID ID
; // == ImHash(Name)
961 ImGuiWindowFlags Flags
; // See enum ImGuiWindowFlags_
962 ImVec2 Pos
; // Position (always rounded-up to nearest pixel)
963 ImVec2 Size
; // Current size (==SizeFull or collapsed title bar size)
964 ImVec2 SizeFull
; // Size when non collapsed
965 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.
966 ImVec2 SizeContents
; // Size of contents (== extents reach of the drawing cursor) from previous frame. Include decoration, window title, border, menu, etc.
967 ImVec2 SizeContentsExplicit
; // Size of contents explicitly set by the user via SetNextWindowContentSize()
968 ImVec2 WindowPadding
; // Window padding at the time of begin.
969 float WindowRounding
; // Window rounding at the time of begin.
970 float WindowBorderSize
; // Window border size at the time of begin.
971 ImGuiID MoveId
; // == window->GetID("#MOVE")
972 ImGuiID ChildId
; // ID of corresponding item in parent window (for navigation to return from child window to parent window)
974 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)
975 ImVec2 ScrollTargetCenterRatio
; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
976 ImVec2 ScrollbarSizes
; // Size taken by scrollbars on each axis
977 bool ScrollbarX
, ScrollbarY
;
978 bool Active
; // Set to true on Begin(), unless Collapsed
980 bool WriteAccessed
; // Set to true when any widget access the current window
981 bool Collapsed
; // Set when collapsing window to become only title-bar
982 bool CollapseToggleWanted
;
983 bool SkipItems
; // Set when items can safely be all clipped (e.g. window not visible or collapsed)
984 bool Appearing
; // Set during the frame where the window is appearing (or re-appearing)
985 bool Hidden
; // Do not display (== (HiddenFramesForResize > 0) ||
986 bool HasCloseButton
; // Set when the window has a close button (p_open != NULL)
987 int BeginOrderWithinParent
; // Order within immediate parent window, if we are a child window. Otherwise 0.
988 int BeginOrderWithinContext
; // Order within entire imgui context. This is mostly used for debugging submission order related issues.
989 int BeginCount
; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
990 ImGuiID PopupId
; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
991 int AutoFitFramesX
, AutoFitFramesY
;
992 bool AutoFitOnlyGrows
;
993 int AutoFitChildAxises
;
994 ImGuiDir AutoPosLastDirection
;
995 int HiddenFramesRegular
; // Hide the window for N frames
996 int HiddenFramesForResize
; // Hide the window for N frames while allowing items to be submitted so we can measure their size
997 ImGuiCond SetWindowPosAllowFlags
; // store acceptable condition flags for SetNextWindowPos() use.
998 ImGuiCond SetWindowSizeAllowFlags
; // store acceptable condition flags for SetNextWindowSize() use.
999 ImGuiCond SetWindowCollapsedAllowFlags
; // store acceptable condition flags for SetNextWindowCollapsed() use.
1000 ImVec2 SetWindowPosVal
; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
1001 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.
1003 ImGuiWindowTempData DC
; // Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the "DC" variable name.
1004 ImVector
<ImGuiID
> IDStack
; // ID stack. ID are hashes seeded with the value at the top of the stack
1005 ImRect ClipRect
; // Current clipping rectangle. = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2.
1006 ImRect OuterRectClipped
; // = WindowRect just after setup in Begin(). == window->Rect() for root window.
1007 ImRect InnerMainRect
, InnerClipRect
;
1008 ImRect ContentsRegionRect
; // FIXME: This is currently confusing/misleading. Maximum visible content position ~~ Pos + (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis
1009 int LastFrameActive
; // Last frame number the window was Active.
1010 float ItemWidthDefault
;
1011 ImGuiMenuColumns MenuColumns
; // Simplified columns storage for menu items
1012 ImGuiStorage StateStorage
;
1013 ImVector
<ImGuiColumnsSet
> ColumnsStorage
;
1014 float FontWindowScale
; // User scale multiplier per-window
1015 int SettingsIdx
; // Index into SettingsWindow[] (indices are always valid as we only grow the array from the back)
1017 ImDrawList
* DrawList
; // == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer)
1018 ImDrawList DrawListInst
;
1019 ImGuiWindow
* ParentWindow
; // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
1020 ImGuiWindow
* RootWindow
; // Point to ourself or first ancestor that is not a child window.
1021 ImGuiWindow
* RootWindowForTitleBarHighlight
; // Point to ourself or first ancestor which will display TitleBgActive color when this window is active.
1022 ImGuiWindow
* RootWindowForNav
; // Point to ourself or first ancestor which doesn't have the NavFlattened flag.
1024 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.)
1025 ImGuiID NavLastIds
[2]; // Last known NavId for this window, per layer (0/1)
1026 ImRect NavRectRel
[2]; // Reference rectangle, in window relative space
1028 // Navigation / Focus
1029 // FIXME-NAV: Merge all this with the new Nav system, at least the request variables should be moved to ImGuiContext
1030 int FocusIdxAllCounter
; // Start at -1 and increase as assigned via FocusItemRegister()
1031 int FocusIdxTabCounter
; // (same, but only count widgets which you can Tab through)
1032 int FocusIdxAllRequestCurrent
; // Item being requested for focus
1033 int FocusIdxTabRequestCurrent
; // Tab-able item being requested for focus
1034 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)
1035 int FocusIdxTabRequestNext
; // "
1038 ImGuiWindow(ImGuiContext
* context
, const char* name
);
1041 ImGuiID
GetID(const char* str
, const char* str_end
= NULL
);
1042 ImGuiID
GetID(const void* ptr
);
1043 ImGuiID
GetIDNoKeepAlive(const char* str
, const char* str_end
= NULL
);
1044 ImGuiID
GetIDFromRectangle(const ImRect
& r_abs
);
1046 // We don't use g.FontSize because the window may be != g.CurrentWidow.
1047 ImRect
Rect() const { return ImRect(Pos
.x
, Pos
.y
, Pos
.x
+Size
.x
, Pos
.y
+Size
.y
); }
1048 float CalcFontSize() const { return GImGui
->FontBaseSize
* FontWindowScale
; }
1049 float TitleBarHeight() const { return (Flags
& ImGuiWindowFlags_NoTitleBar
) ? 0.0f
: CalcFontSize() + GImGui
->Style
.FramePadding
.y
* 2.0f
; }
1050 ImRect
TitleBarRect() const { return ImRect(Pos
, ImVec2(Pos
.x
+ SizeFull
.x
, Pos
.y
+ TitleBarHeight())); }
1051 float MenuBarHeight() const { return (Flags
& ImGuiWindowFlags_MenuBar
) ? DC
.MenuBarOffset
.y
+ CalcFontSize() + GImGui
->Style
.FramePadding
.y
* 2.0f
: 0.0f
; }
1052 ImRect
MenuBarRect() const { float y1
= Pos
.y
+ TitleBarHeight(); return ImRect(Pos
.x
, y1
, Pos
.x
+ SizeFull
.x
, y1
+ MenuBarHeight()); }
1055 // 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.
1056 struct ImGuiItemHoveredDataBackup
1059 ImGuiItemStatusFlags LastItemStatusFlags
;
1060 ImRect LastItemRect
;
1061 ImRect LastItemDisplayRect
;
1063 ImGuiItemHoveredDataBackup() { Backup(); }
1064 void Backup() { ImGuiWindow
* window
= GImGui
->CurrentWindow
; LastItemId
= window
->DC
.LastItemId
; LastItemStatusFlags
= window
->DC
.LastItemStatusFlags
; LastItemRect
= window
->DC
.LastItemRect
; LastItemDisplayRect
= window
->DC
.LastItemDisplayRect
; }
1065 void Restore() const { ImGuiWindow
* window
= GImGui
->CurrentWindow
; window
->DC
.LastItemId
= LastItemId
; window
->DC
.LastItemStatusFlags
= LastItemStatusFlags
; window
->DC
.LastItemRect
= LastItemRect
; window
->DC
.LastItemDisplayRect
= LastItemDisplayRect
; }
1068 //-----------------------------------------------------------------------------
1070 // No guarantee of forward compatibility here.
1071 //-----------------------------------------------------------------------------
1075 // We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
1076 // If this ever crash because g.CurrentWindow is NULL it means that either
1077 // - ImGui::NewFrame() has never been called, which is illegal.
1078 // - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
1079 inline ImGuiWindow
* GetCurrentWindowRead() { ImGuiContext
& g
= *GImGui
; return g
.CurrentWindow
; }
1080 inline ImGuiWindow
* GetCurrentWindow() { ImGuiContext
& g
= *GImGui
; g
.CurrentWindow
->WriteAccessed
= true; return g
.CurrentWindow
; }
1081 IMGUI_API ImGuiWindow
* FindWindowByName(const char* name
);
1082 IMGUI_API
void FocusWindow(ImGuiWindow
* window
);
1083 IMGUI_API
void BringWindowToFront(ImGuiWindow
* window
);
1084 IMGUI_API
void BringWindowToBack(ImGuiWindow
* window
);
1085 IMGUI_API
void UpdateWindowParentAndRootLinks(ImGuiWindow
* window
, ImGuiWindowFlags flags
, ImGuiWindow
* parent_window
);
1086 IMGUI_API
bool IsWindowChildOf(ImGuiWindow
* window
, ImGuiWindow
* potential_parent
);
1087 IMGUI_API
bool IsWindowNavFocusable(ImGuiWindow
* window
);
1088 IMGUI_API
void SetCurrentFont(ImFont
* font
);
1089 inline ImFont
* GetDefaultFont() { ImGuiContext
& g
= *GImGui
; return g
.IO
.FontDefault
? g
.IO
.FontDefault
: g
.IO
.Fonts
->Fonts
[0]; }
1092 IMGUI_API
void Initialize(ImGuiContext
* context
);
1093 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().
1096 IMGUI_API
void UpdateHoveredWindowAndCaptureFlags();
1097 IMGUI_API
void StartMouseMovingWindow(ImGuiWindow
* window
);
1098 IMGUI_API
void UpdateMouseMovingWindow();
1101 IMGUI_API
void MarkIniSettingsDirty();
1102 IMGUI_API
void MarkIniSettingsDirty(ImGuiWindow
* window
);
1103 IMGUI_API ImGuiSettingsHandler
* FindSettingsHandler(const char* type_name
);
1104 IMGUI_API ImGuiWindowSettings
* FindWindowSettings(ImGuiID id
);
1107 inline ImGuiID
GetItemID() { ImGuiContext
& g
= *GImGui
; return g
.CurrentWindow
->DC
.LastItemId
; }
1108 inline ImGuiID
GetActiveID() { ImGuiContext
& g
= *GImGui
; return g
.ActiveId
; }
1109 inline ImGuiID
GetFocusID() { ImGuiContext
& g
= *GImGui
; return g
.NavId
; }
1110 IMGUI_API
void SetActiveID(ImGuiID id
, ImGuiWindow
* window
);
1111 IMGUI_API
void SetFocusID(ImGuiID id
, ImGuiWindow
* window
);
1112 IMGUI_API
void ClearActiveID();
1113 IMGUI_API ImGuiID
GetHoveredID();
1114 IMGUI_API
void SetHoveredID(ImGuiID id
);
1115 IMGUI_API
void KeepAliveID(ImGuiID id
);
1116 IMGUI_API
void MarkItemValueChanged(ImGuiID id
);
1118 // Basic Helpers for widget code
1119 IMGUI_API
void ItemSize(const ImVec2
& size
, float text_offset_y
= 0.0f
);
1120 IMGUI_API
void ItemSize(const ImRect
& bb
, float text_offset_y
= 0.0f
);
1121 IMGUI_API
bool ItemAdd(const ImRect
& bb
, ImGuiID id
, const ImRect
* nav_bb
= NULL
);
1122 IMGUI_API
bool ItemHoverable(const ImRect
& bb
, ImGuiID id
);
1123 IMGUI_API
bool IsClippedEx(const ImRect
& bb
, ImGuiID id
, bool clip_even_when_logged
);
1124 IMGUI_API
bool FocusableItemRegister(ImGuiWindow
* window
, ImGuiID id
, bool tab_stop
= true); // Return true if focus is requested
1125 IMGUI_API
void FocusableItemUnregister(ImGuiWindow
* window
);
1126 IMGUI_API ImVec2
CalcItemSize(ImVec2 size
, float default_x
, float default_y
);
1127 IMGUI_API
float CalcWrapWidthForPos(const ImVec2
& pos
, float wrap_pos_x
);
1128 IMGUI_API
void PushMultiItemsWidths(int components
, float width_full
= 0.0f
);
1129 IMGUI_API
void PushItemFlag(ImGuiItemFlags option
, bool enabled
);
1130 IMGUI_API
void PopItemFlag();
1132 // Popups, Modals, Tooltips
1133 IMGUI_API
void OpenPopupEx(ImGuiID id
);
1134 IMGUI_API
void ClosePopup(ImGuiID id
);
1135 IMGUI_API
void ClosePopupToLevel(int remaining
);
1136 IMGUI_API
void ClosePopupsOverWindow(ImGuiWindow
* ref_window
);
1137 IMGUI_API
bool IsPopupOpen(ImGuiID id
);
1138 IMGUI_API
bool BeginPopupEx(ImGuiID id
, ImGuiWindowFlags extra_flags
);
1139 IMGUI_API
void BeginTooltipEx(ImGuiWindowFlags extra_flags
, bool override_previous_tooltip
= true);
1140 IMGUI_API ImGuiWindow
* GetFrontMostPopupModal();
1143 IMGUI_API
void NavInitWindow(ImGuiWindow
* window
, bool force_reinit
);
1144 IMGUI_API
void NavMoveRequestCancel();
1145 IMGUI_API
void NavMoveRequestForward(ImGuiDir move_dir
, ImGuiDir clip_dir
, const ImRect
& bb_rel
, ImGuiNavMoveFlags move_flags
);
1146 IMGUI_API
void NavMoveRequestTryWrapping(ImGuiWindow
* window
, ImGuiNavMoveFlags move_flags
);
1147 IMGUI_API
float GetNavInputAmount(ImGuiNavInput n
, ImGuiInputReadMode mode
);
1148 IMGUI_API ImVec2
GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources
, ImGuiInputReadMode mode
, float slow_factor
= 0.0f
, float fast_factor
= 0.0f
);
1149 IMGUI_API
int CalcTypematicPressedRepeatAmount(float t
, float t_prev
, float repeat_delay
, float repeat_rate
);
1150 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.
1153 IMGUI_API
bool BeginDragDropTargetCustom(const ImRect
& bb
, ImGuiID id
);
1154 IMGUI_API
void ClearDragDrop();
1155 IMGUI_API
bool IsDragDropPayloadBeingAccepted();
1157 // New Columns API (FIXME-WIP)
1158 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().
1159 IMGUI_API
void EndColumns(); // close columns
1160 IMGUI_API
void PushColumnClipRect(int column_index
= -1);
1163 // 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.
1164 // NB: All position are in absolute pixels coordinates (never using window coordinates internally)
1165 IMGUI_API
void RenderText(ImVec2 pos
, const char* text
, const char* text_end
= NULL
, bool hide_text_after_hash
= true);
1166 IMGUI_API
void RenderTextWrapped(ImVec2 pos
, const char* text
, const char* text_end
, float wrap_width
);
1167 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
);
1168 IMGUI_API
void RenderFrame(ImVec2 p_min
, ImVec2 p_max
, ImU32 fill_col
, bool border
= true, float rounding
= 0.0f
);
1169 IMGUI_API
void RenderFrameBorder(ImVec2 p_min
, ImVec2 p_max
, float rounding
= 0.0f
);
1170 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);
1171 IMGUI_API
void RenderArrow(ImVec2 pos
, ImGuiDir dir
, float scale
= 1.0f
);
1172 IMGUI_API
void RenderArrowPointingAt(ImDrawList
* draw_list
, ImVec2 pos
, ImVec2 half_sz
, ImGuiDir direction
, ImU32 col
);
1173 IMGUI_API
void RenderBullet(ImVec2 pos
);
1174 IMGUI_API
void RenderCheckMark(ImVec2 pos
, ImU32 col
, float sz
);
1175 IMGUI_API
void RenderNavHighlight(const ImRect
& bb
, ImGuiID id
, ImGuiNavHighlightFlags flags
= ImGuiNavHighlightFlags_TypeDefault
); // Navigation highlight
1176 IMGUI_API
void RenderRectFilledRangeH(ImDrawList
* draw_list
, const ImRect
& rect
, ImU32 col
, float x_start_norm
, float x_end_norm
, float rounding
);
1177 IMGUI_API
const char* FindRenderedTextEnd(const char* text
, const char* text_end
= NULL
); // Find the optional ## from which we stop displaying text.
1180 IMGUI_API
bool ButtonEx(const char* label
, const ImVec2
& size_arg
= ImVec2(0,0), ImGuiButtonFlags flags
= 0);
1181 IMGUI_API
bool CloseButton(ImGuiID id
, const ImVec2
& pos
, float radius
);
1182 IMGUI_API
bool CollapseButton(ImGuiID id
, const ImVec2
& pos
);
1183 IMGUI_API
bool ArrowButtonEx(const char* str_id
, ImGuiDir dir
, ImVec2 size_arg
, ImGuiButtonFlags flags
);
1184 IMGUI_API
void Scrollbar(ImGuiLayoutType direction
);
1185 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.
1187 // Widgets low-level behaviors
1188 IMGUI_API
bool ButtonBehavior(const ImRect
& bb
, ImGuiID id
, bool* out_hovered
, bool* out_held
, ImGuiButtonFlags flags
= 0);
1189 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
);
1190 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
= 0);
1191 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
);
1192 IMGUI_API
bool TreeNodeBehavior(ImGuiID id
, ImGuiTreeNodeFlags flags
, const char* label
, const char* label_end
= NULL
);
1193 IMGUI_API
bool TreeNodeBehaviorIsOpen(ImGuiID id
, ImGuiTreeNodeFlags flags
= 0); // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging
1194 IMGUI_API
void TreePushRawID(ImGuiID id
);
1196 IMGUI_API
bool InputTextEx(const char* label
, char* buf
, int buf_size
, const ImVec2
& size_arg
, ImGuiInputTextFlags flags
, ImGuiTextEditCallback callback
= NULL
, void* user_data
= NULL
);
1197 IMGUI_API
bool InputScalarAsWidgetReplacement(const ImRect
& bb
, ImGuiID id
, const char* label
, ImGuiDataType data_type
, void* data_ptr
, const char* format
);
1199 IMGUI_API
void ColorTooltip(const char* text
, const float* col
, ImGuiColorEditFlags flags
);
1200 IMGUI_API
void ColorEditOptionsPopup(const float* col
, ImGuiColorEditFlags flags
);
1202 IMGUI_API
void PlotEx(ImGuiPlotType plot_type
, const char* label
, float (*values_getter
)(void* data
, int idx
), void* data
, int values_count
, int values_offset
, const char* overlay_text
, float scale_min
, float scale_max
, ImVec2 graph_size
);
1204 // Shade functions (write over already created vertices)
1205 IMGUI_API
void ShadeVertsLinearColorGradientKeepAlpha(ImDrawVert
* vert_start
, ImDrawVert
* vert_end
, ImVec2 gradient_p0
, ImVec2 gradient_p1
, ImU32 col0
, ImU32 col1
);
1206 IMGUI_API
void ShadeVertsLinearUV(ImDrawVert
* vert_start
, ImDrawVert
* vert_end
, const ImVec2
& a
, const ImVec2
& b
, const ImVec2
& uv_a
, const ImVec2
& uv_b
, bool clamp
);
1208 } // namespace ImGui
1210 // ImFontAtlas internals
1211 IMGUI_API
bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas
* atlas
);
1212 IMGUI_API
void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas
* atlas
);
1213 IMGUI_API
void ImFontAtlasBuildSetupFont(ImFontAtlas
* atlas
, ImFont
* font
, ImFontConfig
* font_config
, float ascent
, float descent
);
1214 IMGUI_API
void ImFontAtlasBuildPackCustomRects(ImFontAtlas
* atlas
, void* spc
);
1215 IMGUI_API
void ImFontAtlasBuildFinish(ImFontAtlas
* atlas
);
1216 IMGUI_API
void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table
[256], float in_multiply_factor
);
1217 IMGUI_API
void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table
[256], unsigned char* pixels
, int x
, int y
, int w
, int h
, int stride
);
1220 #pragma clang diagnostic pop
1224 #pragma warning (pop)