projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
build: move imgui out of src/intel/tools to be reused
[mesa.git] / src / imgui / imgui_internal.h
1 // dear imgui, v1.63 WIP
2 // (internals)
3
4 // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
5 // Set:
6 // #define IMGUI_DEFINE_MATH_OPERATORS
7 // To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
8
9 #pragma once
10
11 #ifndef IMGUI_VERSION
12 #error Must include imgui.h before imgui_internal.h
13 #endif
14
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
19
20 #ifdef _MSC_VER
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)
23 #endif
24
25 #ifdef __clang__
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"
30 #endif
31
32 //-----------------------------------------------------------------------------
33 // Forward Declarations
34 //-----------------------------------------------------------------------------
35
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)
55
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_
65
66 //-------------------------------------------------------------------------
67 // STB libraries
68 //-------------------------------------------------------------------------
69
70 namespace ImGuiStb
71 {
72
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"
79
80 } // namespace ImGuiStb
81
82 //-----------------------------------------------------------------------------
83 // Context
84 //-----------------------------------------------------------------------------
85
86 #ifndef GImGui
87 extern IMGUI_API ImGuiContext* GImGui; // Current implicit ImGui context pointer
88 #endif
89
90 //-----------------------------------------------------------------------------
91 // Helpers
92 //-----------------------------------------------------------------------------
93
94 #define IM_PI 3.14159265358979323846f
95 #ifdef _WIN32
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!)
97 #else
98 #define IM_NEWLINE "\n"
99 #endif
100
101 // Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
102 #ifdef _MSC_VER
103 #define IMGUI_CDECL __cdecl
104 #else
105 #define IMGUI_CDECL
106 #endif
107
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
114
115 // Helpers: Misc
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
124
125 // Helpers: Geometry
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);
130
131 // Helpers: String
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);
147
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); }
165 #endif
166
167 // Helpers: Maths
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); }
183 #endif
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); }
207
208 //-----------------------------------------------------------------------------
209 // Types
210 //-----------------------------------------------------------------------------
211
212 enum ImGuiButtonFlags_
213 {
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
229 };
230
231 enum ImGuiSliderFlags_
232 {
233 ImGuiSliderFlags_None = 0,
234 ImGuiSliderFlags_Vertical = 1 << 0
235 };
236
237 enum ImGuiColumnsFlags_
238 {
239 // Default: 0
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.
246 };
247
248 enum ImGuiSelectableFlagsPrivate_
249 {
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
256 };
257
258 enum ImGuiSeparatorFlags_
259 {
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
263 };
264
265 // Storage for LastItem data
266 enum ImGuiItemStatusFlags_
267 {
268 ImGuiItemStatusFlags_None = 0,
269 ImGuiItemStatusFlags_HoveredRect = 1 << 0,
270 ImGuiItemStatusFlags_HasDisplayRect = 1 << 1
271 };
272
273 // FIXME: this is in development, not exposed/functional as a generic feature yet.
274 enum ImGuiLayoutType_
275 {
276 ImGuiLayoutType_Vertical,
277 ImGuiLayoutType_Horizontal
278 };
279
280 enum ImGuiAxis
281 {
282 ImGuiAxis_None = -1,
283 ImGuiAxis_X = 0,
284 ImGuiAxis_Y = 1
285 };
286
287 enum ImGuiPlotType
288 {
289 ImGuiPlotType_Lines,
290 ImGuiPlotType_Histogram
291 };
292
293 enum ImGuiInputSource
294 {
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
301 };
302
303 // FIXME-NAV: Clarify/expose various repeat delay/rate
304 enum ImGuiInputReadMode
305 {
306 ImGuiInputReadMode_Down,
307 ImGuiInputReadMode_Pressed,
308 ImGuiInputReadMode_Released,
309 ImGuiInputReadMode_Repeat,
310 ImGuiInputReadMode_RepeatSlow,
311 ImGuiInputReadMode_RepeatFast
312 };
313
314 enum ImGuiNavHighlightFlags_
315 {
316 ImGuiNavHighlightFlags_TypeDefault = 1 << 0,
317 ImGuiNavHighlightFlags_TypeThin = 1 << 1,
318 ImGuiNavHighlightFlags_AlwaysDraw = 1 << 2,
319 ImGuiNavHighlightFlags_NoRounding = 1 << 3
320 };
321
322 enum ImGuiNavDirSourceFlags_
323 {
324 ImGuiNavDirSourceFlags_Keyboard = 1 << 0,
325 ImGuiNavDirSourceFlags_PadDPad = 1 << 1,
326 ImGuiNavDirSourceFlags_PadLStick = 1 << 2
327 };
328
329 enum ImGuiNavMoveFlags_
330 {
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.
337 };
338
339 enum ImGuiNavForward
340 {
341 ImGuiNavForward_None,
342 ImGuiNavForward_ForwardQueued,
343 ImGuiNavForward_ForwardActive
344 };
345
346 // 2D axis aligned bounding-box
347 // NB: we can't rely on ImVec2 math operators being available here
348 struct IMGUI_API ImRect
349 {
350 ImVec2 Min; // Upper-left
351 ImVec2 Max; // Lower-right
352
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) {}
357
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; }
380 };
381
382 // Stacked color modifier, backup of modified data so we can restore it
383 struct ImGuiColMod
384 {
385 ImGuiCol Col;
386 ImVec4 BackupValue;
387 };
388
389 // Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
390 struct ImGuiStyleMod
391 {
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; }
397 };
398
399 // Stacked storage data for BeginGroup()/EndGroup()
400 struct ImGuiGroupData
401 {
402 ImVec2 BackupCursorPos;
403 ImVec2 BackupCursorMaxPos;
404 float BackupIndentX;
405 float BackupGroupOffsetX;
406 float BackupCurrentLineHeight;
407 float BackupCurrentLineTextBaseOffset;
408 float BackupLogLinePosY;
409 bool BackupActiveIdIsAlive;
410 bool BackupActiveIdPreviousFrameIsAlive;
411 bool AdvanceCursor;
412 };
413
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
416 {
417 int Count;
418 float Spacing;
419 float Width, NextWidth;
420 float Pos[4], NextWidths[4];
421
422 ImGuiMenuColumns();
423 void Update(int count, float spacing, bool clear);
424 float DeclColumns(float w0, float w1, float w2);
425 float CalcExtraSpace(float avail_w);
426 };
427
428 // Internal state of the currently focused/edited text input box
429 struct IMGUI_API ImGuiTextEditState
430 {
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
437 float ScrollX;
438 ImGuiStb::STB_TexteditState StbState;
439 float CursorAnim;
440 bool CursorFollow;
441 bool SelectedAllMouseLock;
442
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);
450 };
451
452 // Windows data saved in imgui.ini file
453 struct ImGuiWindowSettings
454 {
455 char* Name;
456 ImGuiID ID;
457 ImVec2 Pos;
458 ImVec2 Size;
459 bool Collapsed;
460
461 ImGuiWindowSettings() { Name = NULL; ID = 0; Pos = Size = ImVec2(0,0); Collapsed = false; }
462 };
463
464 struct ImGuiSettingsHandler
465 {
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'
471 void* UserData;
472
473 ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
474 };
475
476 // Storage for current popup stack
477 struct ImGuiPopupRef
478 {
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
486 };
487
488 struct ImGuiColumnData
489 {
490 float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
491 float OffsetNormBeforeResize;
492 ImGuiColumnsFlags Flags; // Not exposed
493 ImRect ClipRect;
494
495 ImGuiColumnData() { OffsetNorm = OffsetNormBeforeResize = 0.0f; Flags = 0; }
496 };
497
498 struct ImGuiColumnsSet
499 {
500 ImGuiID ID;
501 ImGuiColumnsFlags Flags;
502 bool IsFirstFrame;
503 bool IsBeingResized;
504 int Current;
505 int Count;
506 float MinX, MaxX;
507 float LineMinY, LineMaxY;
508 float StartPosY; // Copy of CursorPos
509 float StartMaxPosX; // Copy of CursorMaxPos
510 ImVector<ImGuiColumnData> Columns;
511
512 ImGuiColumnsSet() { Clear(); }
513 void Clear()
514 {
515 ID = 0;
516 Flags = 0;
517 IsFirstFrame = false;
518 IsBeingResized = false;
519 Current = 0;
520 Count = 1;
521 MinX = MaxX = 0.0f;
522 LineMinY = LineMaxY = 0.0f;
523 StartPosY = 0.0f;
524 StartMaxPosX = 0.0f;
525 Columns.clear();
526 }
527 };
528
529 // Data shared between all ImDrawList instances
530 struct IMGUI_API ImDrawListSharedData
531 {
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()
537
538 // Const data
539 // FIXME: Bake rounded corners fill/borders in atlas
540 ImVec2 CircleVtx12[12];
541
542 ImDrawListSharedData();
543 };
544
545 struct ImDrawDataBuilder
546 {
547 ImVector<ImDrawList*> Layers[2]; // Global layers for: regular, tooltip
548
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();
552 };
553
554 struct ImGuiNavMoveResult
555 {
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
560 float DistAxial;
561 ImRect RectRel; // Best candidate bounding box in window relative space
562
563 ImGuiNavMoveResult() { Clear(); }
564 void Clear() { ID = 0; Window = NULL; DistBox = DistCenter = DistAxial = FLT_MAX; RectRel = ImRect(); }
565 };
566
567 // Storage for SetNexWindow** functions
568 struct ImGuiNextWindowData
569 {
570 ImGuiCond PosCond;
571 ImGuiCond SizeCond;
572 ImGuiCond ContentSizeCond;
573 ImGuiCond CollapsedCond;
574 ImGuiCond SizeConstraintCond;
575 ImGuiCond FocusCond;
576 ImGuiCond BgAlphaCond;
577 ImVec2 PosVal;
578 ImVec2 PosPivotVal;
579 ImVec2 SizeVal;
580 ImVec2 ContentSizeVal;
581 bool CollapsedVal;
582 ImRect SizeConstraintRect;
583 ImGuiSizeCallback SizeCallback;
584 void* SizeCallbackUserData;
585 float BgAlphaVal;
586 ImVec2 MenuBarOffsetMinVal; // This is not exposed publicly, so we don't clear it.
587
588 ImGuiNextWindowData()
589 {
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();
595 SizeCallback = NULL;
596 SizeCallbackUserData = NULL;
597 BgAlphaVal = FLT_MAX;
598 MenuBarOffsetMinVal = ImVec2(0.0f, 0.0f);
599 }
600
601 void Clear()
602 {
603 PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = BgAlphaCond = 0;
604 }
605 };
606
607 // Main imgui context
608 struct ImGuiContext
609 {
610 bool Initialized;
611 bool FontAtlasOwnedByContext; // Io.Fonts-> is owned by the ImGuiContext and will be destructed along with it.
612 ImGuiIO IO;
613 ImGuiStyle Style;
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;
618
619 double Time;
620 int FrameCount;
621 int FrameCountEnded;
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;
637 float ActiveIdTimer;
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;
660
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)
700
701 // Render
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;
707
708 // Drag and Drop
709 bool DragDropActive;
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
723
724 // Widget state
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
737
738 // Settings
739 bool SettingsLoaded;
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)
744
745 // Logging
746 bool LogEnabled;
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.
749 int LogStartDepth;
750 int LogAutoExpandMaxDepth;
751
752 // Misc
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
760
761 ImGuiContext(ImFontAtlas* shared_font_atlas) : OverlayDrawList(NULL)
762 {
763 Initialized = false;
764 Font = 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)();
768
769 Time = 0.0f;
770 FrameCount = 0;
771 FrameCountEnded = FrameCountRendered = -1;
772 WindowsActiveCount = 0;
773 CurrentWindow = NULL;
774 HoveredWindow = NULL;
775 HoveredRootWindow = NULL;
776 HoveredId = 0;
777 HoveredIdAllowOverlap = false;
778 HoveredIdPreviousFrame = 0;
779 HoveredIdTimer = 0.0f;
780 ActiveId = 0;
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;
793 LastActiveId = 0;
794 LastActiveIdTimer = 0.0f;
795 MovingWindow = NULL;
796 NextTreeNodeOpenVal = false;
797 NextTreeNodeOpenCond = 0;
798
799 NavWindow = NULL;
800 NavId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavInputId = 0;
801 NavJustTabbedId = NavJustMovedToId = NavNextActivateId = 0;
802 NavInputSource = ImGuiInputSource_None;
803 NavScoringRectScreen = ImRect();
804 NavScoringCount = 0;
805 NavWindowingTarget = NavWindowingTargetAnim = NavWindowingList = NULL;
806 NavWindowingTimer = NavWindowingHighlightAlpha = 0.0f;
807 NavWindowingToggleLayer = false;
808 NavLayer = 0;
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;
817 NavInitResultId = 0;
818 NavMoveFromClampedRefRect = false;
819 NavMoveRequest = false;
820 NavMoveRequestFlags = 0;
821 NavMoveRequestForward = ImGuiNavForward_None;
822 NavMoveDir = NavMoveDirLast = NavMoveClipDir = ImGuiDir_None;
823
824 DimBgRatio = 0.0f;
825 OverlayDrawList._Data = &DrawListSharedData;
826 OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging
827 MouseCursor = ImGuiMouseCursor_Arrow;
828
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));
838
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);
847
848 SettingsLoaded = false;
849 SettingsDirtyTimer = 0.0f;
850
851 LogEnabled = false;
852 LogFile = NULL;
853 LogStartDepth = 0;
854 LogAutoExpandMaxDepth = 2;
855
856 memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
857 FramerateSecPerFrameIdx = 0;
858 FramerateSecPerFrameAccum = 0.0f;
859 WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
860 memset(TempBuffer, 0, sizeof(TempBuffer));
861 }
862 };
863
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.
866 enum ImGuiItemFlags_
867 {
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
875 };
876
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
880 {
881 ImVec2 CursorPos;
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;
889 float LogLinePosY;
890 int TreeDepth;
891 ImU32 TreeDepthMayJumpToParentOnPop; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31
892 ImGuiID LastItemId;
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()
908
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
918
919 float IndentX; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
920 float GroupOffsetX;
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
923
924 ImGuiWindowTempData()
925 {
926 CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f);
927 CurrentLineHeight = PrevLineHeight = 0.0f;
928 CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f;
929 LogLinePosY = -1.0f;
930 TreeDepth = 0;
931 TreeDepthMayJumpToParentOnPop = 0x00;
932 LastItemId = 0;
933 LastItemStatusFlags = 0;
934 LastItemRect = LastItemDisplayRect = ImRect();
935 NavHideHighlightOneFrame = false;
936 NavHasScroll = false;
937 NavLayerActiveMask = NavLayerActiveMaskNext = 0x00;
938 NavLayerCurrent = 0;
939 NavLayerCurrentMask = 1 << 0;
940 MenuBarAppending = false;
941 MenuBarOffset = ImVec2(0.0f, 0.0f);
942 StateStorage = NULL;
943 LayoutType = ParentLayoutType = ImGuiLayoutType_Vertical;
944 ItemWidth = 0.0f;
945 ItemFlags = ImGuiItemFlags_Default_;
946 TextWrapPos = -1.0f;
947 memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
948
949 IndentX = 0.0f;
950 GroupOffsetX = 0.0f;
951 ColumnsOffsetX = 0.0f;
952 ColumnsSet = NULL;
953 }
954 };
955
956 // Storage for one window
957 struct IMGUI_API ImGuiWindow
958 {
959 char* Name;
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)
973 ImVec2 Scroll;
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
979 bool WasActive;
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.
1002
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)
1016
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.
1023
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
1027
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; // "
1036
1037 public:
1038 ImGuiWindow(ImGuiContext* context, const char* name);
1039 ~ImGuiWindow();
1040
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);
1045
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()); }
1053 };
1054
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
1057 {
1058 ImGuiID LastItemId;
1059 ImGuiItemStatusFlags LastItemStatusFlags;
1060 ImRect LastItemRect;
1061 ImRect LastItemDisplayRect;
1062
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; }
1066 };
1067
1068 //-----------------------------------------------------------------------------
1069 // Internal API
1070 // No guarantee of forward compatibility here.
1071 //-----------------------------------------------------------------------------
1072
1073 namespace ImGui
1074 {
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]; }
1090
1091 // Init
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().
1094
1095 // NewFrame
1096 IMGUI_API void UpdateHoveredWindowAndCaptureFlags();
1097 IMGUI_API void StartMouseMovingWindow(ImGuiWindow* window);
1098 IMGUI_API void UpdateMouseMovingWindow();
1099
1100 // Settings
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);
1105
1106 // Basic Accessors
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);
1117
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();
1131
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();
1141
1142 // Navigation
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.
1151
1152 // Drag and Drop
1153 IMGUI_API bool BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
1154 IMGUI_API void ClearDragDrop();
1155 IMGUI_API bool IsDragDropPayloadBeingAccepted();
1156
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);
1161
1162 // Render helpers
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.
1178
1179 // Widgets
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.
1186
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);
1195
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);
1198
1199 IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
1200 IMGUI_API void ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
1201
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);
1203
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);
1207
1208 } // namespace ImGui
1209
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);
1218
1219 #ifdef __clang__
1220 #pragma clang diagnostic pop
1221 #endif
1222
1223 #ifdef _MSC_VER
1224 #pragma warning (pop)
1225 #endif