1
// dear imgui, v1.68 WIP
2
// (internal structures/api)
4
// You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
6
// #define IMGUI_DEFINE_MATH_OPERATORS
7
// To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
13
// Forward declarations
14
// STB libraries includes
17
// Misc data structures
26
//-----------------------------------------------------------------------------
28
//-----------------------------------------------------------------------------
31
#error Must include imgui.h before imgui_internal.h
34
#include <stdio.h> // FILE*
35
#include <stdlib.h> // NULL, malloc, free, qsort, atoi, atof
36
#include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
37
#include <limits.h> // INT_MIN, INT_MAX
40
#pragma warning (push)
41
#pragma warning (disable: 4251) // class 'xxx' needs to have dll-interface to be used by clients of struct 'xxx' // when IMGUI_API is set to__declspec(dllexport)
45
#pragma clang diagnostic push
46
#pragma clang diagnostic ignored "-Wunused-function" // for stb_textedit.h
47
#pragma clang diagnostic ignored "-Wmissing-prototypes" // for stb_textedit.h
48
#pragma clang diagnostic ignored "-Wold-style-cast"
49
#if __has_warning("-Wzero-as-null-pointer-constant")
50
#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
52
#if __has_warning("-Wdouble-promotion")
53
#pragma clang diagnostic ignored "-Wdouble-promotion"
57
//-----------------------------------------------------------------------------
58
// Forward declarations
59
//-----------------------------------------------------------------------------
61
struct ImRect; // An axis-aligned rectangle (2 points)
62
struct ImDrawDataBuilder; // Helper to build a ImDrawData instance
63
struct ImDrawListSharedData; // Data shared between all ImDrawList instances
64
struct ImGuiColorMod; // Stacked color modifier, backup of modified data so we can restore it
65
struct ImGuiColumnData; // Storage data for a single column
66
struct ImGuiColumnsSet; // Storage data for a columns set
67
struct ImGuiContext; // Main imgui context
68
struct ImGuiGroupData; // Stacked storage data for BeginGroup()/EndGroup()
69
struct ImGuiInputTextState; // Internal state of the currently focused/edited text input box
70
struct ImGuiItemHoveredDataBackup; // Backup and restore IsItemHovered() internal data
71
struct ImGuiMenuColumns; // Simple column measurement, currently used for MenuItem() only
72
struct ImGuiNavMoveResult; // Result of a directional navigation move query result
73
struct ImGuiNextWindowData; // Storage for SetNexWindow** functions
74
struct ImGuiPopupRef; // Storage for current popup stack
75
struct ImGuiSettingsHandler; // Storage for one type registered in the .ini file
76
struct ImGuiStyleMod; // Stacked style modifier, backup of modified data so we can restore it
77
struct ImGuiTabBar; // Storage for a tab bar
78
struct ImGuiTabItem; // Storage for a tab item (within a tab bar)
79
struct ImGuiWindow; // Storage for one window
80
struct ImGuiWindowTempData; // Temporary storage for one window (that's the data which in theory we could ditch at the end of the frame)
81
struct ImGuiWindowSettings; // Storage for window settings stored in .ini file (we keep one of those even if the actual window wasn't instanced during this session)
83
// Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.
84
typedef int ImGuiLayoutType; // -> enum ImGuiLayoutType_ // Enum: Horizontal or vertical
85
typedef int ImGuiButtonFlags; // -> enum ImGuiButtonFlags_ // Flags: for ButtonEx(), ButtonBehavior()
86
typedef int ImGuiItemFlags; // -> enum ImGuiItemFlags_ // Flags: for PushItemFlag()
87
typedef int ImGuiItemStatusFlags; // -> enum ImGuiItemStatusFlags_ // Flags: for DC.LastItemStatusFlags
88
typedef int ImGuiNavHighlightFlags; // -> enum ImGuiNavHighlightFlags_ // Flags: for RenderNavHighlight()
89
typedef int ImGuiNavDirSourceFlags; // -> enum ImGuiNavDirSourceFlags_ // Flags: for GetNavInputAmount2d()
90
typedef int ImGuiNavMoveFlags; // -> enum ImGuiNavMoveFlags_ // Flags: for navigation requests
91
typedef int ImGuiSeparatorFlags; // -> enum ImGuiSeparatorFlags_ // Flags: for Separator() - internal
92
typedef int ImGuiSliderFlags; // -> enum ImGuiSliderFlags_ // Flags: for SliderBehavior()
93
typedef int ImGuiDragFlags; // -> enum ImGuiDragFlags_ // Flags: for DragBehavior()
95
//-------------------------------------------------------------------------
96
// STB libraries includes
97
//-------------------------------------------------------------------------
102
#undef STB_TEXTEDIT_STRING
103
#undef STB_TEXTEDIT_CHARTYPE
104
#define STB_TEXTEDIT_STRING ImGuiInputTextState
105
#define STB_TEXTEDIT_CHARTYPE ImWchar
106
#define STB_TEXTEDIT_GETWIDTH_NEWLINE -1.0f
107
#include "imstb_textedit.h"
109
} // namespace ImGuiStb
111
//-----------------------------------------------------------------------------
113
//-----------------------------------------------------------------------------
116
extern IMGUI_API ImGuiContext* GImGui; // Current implicit ImGui context pointer
119
//-----------------------------------------------------------------------------
121
//-----------------------------------------------------------------------------
123
#define IM_PI 3.14159265358979323846f
125
#define IM_NEWLINE "\r\n" // Play it nice with Windows users (2018/05 news: Microsoft announced that Notepad will finally display Unix-style carriage returns!)
127
#define IM_NEWLINE "\n"
130
#define IMGUI_DEBUG_LOG(_FMT,...) printf("[%05d] " _FMT, GImGui->FrameCount, __VA_ARGS__)
131
#define IM_STATIC_ASSERT(_COND) typedef char static_assertion_##__line__[(_COND)?1:-1]
132
#define IM_F32_TO_INT8_UNBOUND(_VAL) ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f))) // Unsaturated, for display purpose
133
#define IM_F32_TO_INT8_SAT(_VAL) ((int)(ImSaturate(_VAL) * 255.0f + 0.5f)) // Saturated, always output 0..255
135
// Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
137
#define IMGUI_CDECL __cdecl
142
// Helpers: UTF-8 <> wchar
143
IMGUI_API int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count
144
IMGUI_API int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // read one character. return input UTF-8 bytes count
145
IMGUI_API int ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL); // return input UTF-8 bytes count
146
IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count)
147
IMGUI_API int ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end); // return number of bytes to express one char in UTF-8
148
IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string in UTF-8
151
IMGUI_API ImU32 ImHashData(const void* data, size_t data_size, ImU32 seed = 0);
152
IMGUI_API ImU32 ImHashStr(const char* data, size_t data_size, ImU32 seed = 0);
153
IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* file_open_mode, size_t* out_file_size = NULL, int padding_bytes = 0);
154
IMGUI_API FILE* ImFileOpen(const char* filename, const char* file_open_mode);
155
static inline bool ImCharIsBlankA(char c) { return c == ' ' || c == '\t'; }
156
static inline bool ImCharIsBlankW(unsigned int c) { return c == ' ' || c == '\t' || c == 0x3000; }
157
static inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; }
158
static inline int ImUpperPowerOfTwo(int v) { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
159
#define ImQsort qsort
160
#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
161
static inline ImU32 ImHash(const void* data, int size, ImU32 seed = 0) { return size ? ImHashData(data, (size_t)size, seed) : ImHashStr((const char*)data, 0, seed); } // [moved to ImHashStr/ImHashData in 1.68]
165
IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
166
IMGUI_API bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
167
IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
168
IMGUI_API void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
169
IMGUI_API ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy);
172
IMGUI_API int ImStricmp(const char* str1, const char* str2);
173
IMGUI_API int ImStrnicmp(const char* str1, const char* str2, size_t count);
174
IMGUI_API void ImStrncpy(char* dst, const char* src, size_t count);
175
IMGUI_API char* ImStrdup(const char* str);
176
IMGUI_API char* ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str);
177
IMGUI_API const char* ImStrchrRange(const char* str_begin, const char* str_end, char c);
178
IMGUI_API int ImStrlenW(const ImWchar* str);
179
IMGUI_API const char* ImStreolRange(const char* str, const char* str_end); // End end-of-line
180
IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line
181
IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);
182
IMGUI_API void ImStrTrimBlanks(char* str);
183
IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
184
IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
185
IMGUI_API const char* ImParseFormatFindStart(const char* format);
186
IMGUI_API const char* ImParseFormatFindEnd(const char* format);
187
IMGUI_API const char* ImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size);
188
IMGUI_API int ImParseFormatPrecision(const char* format, int default_value);
190
// Helpers: ImVec2/ImVec4 operators
191
// We are keeping those disabled by default so they don't leak in user space, to allow user enabling implicit cast operators between ImVec2 and their own types (using IM_VEC2_CLASS_EXTRA etc.)
192
// We unfortunately don't have a unary- operator for ImVec2 because this would needs to be defined inside the class itself.
193
#ifdef IMGUI_DEFINE_MATH_OPERATORS
194
static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x*rhs, lhs.y*rhs); }
195
static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x/rhs, lhs.y/rhs); }
196
static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x+rhs.x, lhs.y+rhs.y); }
197
static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x-rhs.x, lhs.y-rhs.y); }
198
static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x*rhs.x, lhs.y*rhs.y); }
199
static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x/rhs.x, lhs.y/rhs.y); }
200
static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs) { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; }
201
static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs) { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; }
202
static inline ImVec2& operator*=(ImVec2& lhs, const float rhs) { lhs.x *= rhs; lhs.y *= rhs; return lhs; }
203
static inline ImVec2& operator/=(ImVec2& lhs, const float rhs) { lhs.x /= rhs; lhs.y /= rhs; return lhs; }
204
static inline ImVec4 operator+(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x+rhs.x, lhs.y+rhs.y, lhs.z+rhs.z, lhs.w+rhs.w); }
205
static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x-rhs.x, lhs.y-rhs.y, lhs.z-rhs.z, lhs.w-rhs.w); }
206
static inline ImVec4 operator*(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x*rhs.x, lhs.y*rhs.y, lhs.z*rhs.z, lhs.w*rhs.w); }
210
// - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)
211
#ifndef IMGUI_DISABLE_MATH_FUNCTIONS
212
static inline float ImFabs(float x) { return fabsf(x); }
213
static inline float ImSqrt(float x) { return sqrtf(x); }
214
static inline float ImPow(float x, float y) { return powf(x, y); }
215
static inline double ImPow(double x, double y) { return pow(x, y); }
216
static inline float ImFmod(float x, float y) { return fmodf(x, y); }
217
static inline double ImFmod(double x, double y) { return fmod(x, y); }
218
static inline float ImCos(float x) { return cosf(x); }
219
static inline float ImSin(float x) { return sinf(x); }
220
static inline float ImAcos(float x) { return acosf(x); }
221
static inline float ImAtan2(float y, float x) { return atan2f(y, x); }
222
static inline double ImAtof(const char* s) { return atof(s); }
223
static inline float ImFloorStd(float x) { return floorf(x); } // we already uses our own ImFloor() { return (float)(int)v } internally so the standard one wrapper is named differently (it's used by stb_truetype)
224
static inline float ImCeil(float x) { return ceilf(x); }
226
// - ImMin/ImMax/ImClamp/ImLerp/ImSwap are used by widgets which support for variety of types: signed/unsigned int/long long float/double, using templates here but we could also redefine them 6 times
227
template<typename T> static inline T ImMin(T lhs, T rhs) { return lhs < rhs ? lhs : rhs; }
228
template<typename T> static inline T ImMax(T lhs, T rhs) { return lhs >= rhs ? lhs : rhs; }
229
template<typename T> static inline T ImClamp(T v, T mn, T mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
230
template<typename T> static inline T ImLerp(T a, T b, float t) { return (T)(a + (b - a) * t); }
231
template<typename T> static inline void ImSwap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
232
// - Misc maths helpers
233
static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }
234
static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }
235
static inline ImVec2 ImClamp(const ImVec2& v, const ImVec2& mn, ImVec2 mx) { return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }
236
static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
237
static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t) { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
238
static inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t) { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
239
static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
240
static inline float ImLengthSqr(const ImVec2& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y; }
241
static inline float ImLengthSqr(const ImVec4& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y + lhs.z*lhs.z + lhs.w*lhs.w; }
242
static inline float ImInvLength(const ImVec2& lhs, float fail_value) { float d = lhs.x*lhs.x + lhs.y*lhs.y; if (d > 0.0f) return 1.0f / ImSqrt(d); return fail_value; }
243
static inline float ImFloor(float f) { return (float)(int)f; }
244
static inline ImVec2 ImFloor(const ImVec2& v) { return ImVec2((float)(int)v.x, (float)(int)v.y); }
245
static inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; }
246
static inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a) { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
247
static inline float ImLinearSweep(float current, float target, float speed) { if (current < target) return ImMin(current + speed, target); if (current > target) return ImMax(current - speed, target); return current; }
248
static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
250
// Helper: ImBoolVector. Store 1-bit per value.
251
// Note that Resize() currently clears the whole vector.
254
ImVector<int> Storage;
256
void Resize(int sz) { Storage.resize((sz + 31) >> 5); memset(Storage.Data, 0, (size_t)Storage.Size * sizeof(Storage.Data[0])); }
257
void Clear() { Storage.clear(); }
258
bool GetBit(int n) const { int off = (n >> 5); int mask = 1 << (n & 31); return (Storage[off] & mask) != 0; }
259
void SetBit(int n, bool v) { int off = (n >> 5); int mask = 1 << (n & 31); if (v) Storage[off] |= mask; else Storage[off] &= ~mask; }
262
// Helper: ImPool<>. Basic keyed storage for contiguous instances, slow/amortized insertion, O(1) indexable, O(Log N) queries by ID over a dense/hot buffer,
263
// Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object.
264
typedef int ImPoolIdx;
266
struct IMGUI_API ImPool
268
ImVector<T> Data; // Contiguous data
269
ImGuiStorage Map; // ID->Index
270
ImPoolIdx FreeIdx; // Next free idx to use
272
ImPool() { FreeIdx = 0; }
273
~ImPool() { Clear(); }
274
T* GetByKey(ImGuiID key) { int idx = Map.GetInt(key, -1); return (idx != -1) ? &Data[idx] : NULL; }
275
T* GetByIndex(ImPoolIdx n) { return &Data[n]; }
276
ImPoolIdx GetIndex(const T* p) const { IM_ASSERT(p >= Data.Data && p < Data.Data + Data.Size); return (ImPoolIdx)(p - Data.Data); }
277
T* GetOrAddByKey(ImGuiID key) { int* p_idx = Map.GetIntRef(key, -1); if (*p_idx != -1) return &Data[*p_idx]; *p_idx = FreeIdx; return Add(); }
278
void Clear() { for (int n = 0; n < Map.Data.Size; n++) { int idx = Map.Data[n].val_i; if (idx != -1) Data[idx].~T(); } Map.Clear(); Data.clear(); FreeIdx = 0; }
279
T* Add() { int idx = FreeIdx; if (idx == Data.Size) { Data.resize(Data.Size + 1); FreeIdx++; } else { FreeIdx = *(int*)&Data[idx]; } IM_PLACEMENT_NEW(&Data[idx]) T(); return &Data[idx]; }
280
void Remove(ImGuiID key, const T* p) { Remove(key, GetIndex(p)); }
281
void Remove(ImGuiID key, ImPoolIdx idx) { Data[idx].~T(); *(int*)&Data[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, -1); }
282
void Reserve(int capacity) { Data.reserve(capacity); Map.Data.reserve(capacity); }
283
int GetSize() const { return Data.Size; }
286
//-----------------------------------------------------------------------------
287
// Misc data structures
288
//-----------------------------------------------------------------------------
290
enum ImGuiButtonFlags_
292
ImGuiButtonFlags_None = 0,
293
ImGuiButtonFlags_Repeat = 1 << 0, // hold to repeat
294
ImGuiButtonFlags_PressedOnClickRelease = 1 << 1, // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
295
ImGuiButtonFlags_PressedOnClick = 1 << 2, // return true on click (default requires click+release)
296
ImGuiButtonFlags_PressedOnRelease = 1 << 3, // return true on release (default requires click+release)
297
ImGuiButtonFlags_PressedOnDoubleClick = 1 << 4, // return true on double-click (default requires click+release)
298
ImGuiButtonFlags_FlattenChildren = 1 << 5, // allow interactions even if a child window is overlapping
299
ImGuiButtonFlags_AllowItemOverlap = 1 << 6, // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
300
ImGuiButtonFlags_DontClosePopups = 1 << 7, // disable automatically closing parent popup on press // [UNUSED]
301
ImGuiButtonFlags_Disabled = 1 << 8, // disable interactions
302
ImGuiButtonFlags_AlignTextBaseLine = 1 << 9, // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
303
ImGuiButtonFlags_NoKeyModifiers = 1 << 10, // disable interaction if a key modifier is held
304
ImGuiButtonFlags_NoHoldingActiveID = 1 << 11, // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
305
ImGuiButtonFlags_PressedOnDragDropHold = 1 << 12, // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
306
ImGuiButtonFlags_NoNavFocus = 1 << 13 // don't override navigation focus when activated
309
enum ImGuiSliderFlags_
311
ImGuiSliderFlags_None = 0,
312
ImGuiSliderFlags_Vertical = 1 << 0
317
ImGuiDragFlags_None = 0,
318
ImGuiDragFlags_Vertical = 1 << 0
321
enum ImGuiColumnsFlags_
324
ImGuiColumnsFlags_None = 0,
325
ImGuiColumnsFlags_NoBorder = 1 << 0, // Disable column dividers
326
ImGuiColumnsFlags_NoResize = 1 << 1, // Disable resizing columns when clicking on the dividers
327
ImGuiColumnsFlags_NoPreserveWidths = 1 << 2, // Disable column width preservation when adjusting columns
328
ImGuiColumnsFlags_NoForceWithinWindow = 1 << 3, // Disable forcing columns to fit within window
329
ImGuiColumnsFlags_GrowParentContentsSize= 1 << 4 // (WIP) Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
332
enum ImGuiSelectableFlagsPrivate_
334
// NB: need to be in sync with last value of ImGuiSelectableFlags_
335
ImGuiSelectableFlags_NoHoldingActiveID = 1 << 10,
336
ImGuiSelectableFlags_PressedOnClick = 1 << 11,
337
ImGuiSelectableFlags_PressedOnRelease = 1 << 12,
338
ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 13
341
enum ImGuiSeparatorFlags_
343
ImGuiSeparatorFlags_None = 0,
344
ImGuiSeparatorFlags_Horizontal = 1 << 0, // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
345
ImGuiSeparatorFlags_Vertical = 1 << 1
348
// Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
349
// This is going to be exposed in imgui.h when stabilized enough.
352
ImGuiItemFlags_NoTabStop = 1 << 0, // false
353
ImGuiItemFlags_ButtonRepeat = 1 << 1, // false // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
354
ImGuiItemFlags_Disabled = 1 << 2, // false // [BETA] Disable interactions but doesn't affect visuals yet. See github.com/ocornut/imgui/issues/211
355
ImGuiItemFlags_NoNav = 1 << 3, // false
356
ImGuiItemFlags_NoNavDefaultFocus = 1 << 4, // false
357
ImGuiItemFlags_SelectableDontClosePopup = 1 << 5, // false // MenuItem/Selectable() automatically closes current Popup window
358
ImGuiItemFlags_Default_ = 0
361
// Storage for LastItem data
362
enum ImGuiItemStatusFlags_
364
ImGuiItemStatusFlags_None = 0,
365
ImGuiItemStatusFlags_HoveredRect = 1 << 0,
366
ImGuiItemStatusFlags_HasDisplayRect = 1 << 1,
367
ImGuiItemStatusFlags_Edited = 1 << 2 // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
369
#ifdef IMGUI_ENABLE_TEST_ENGINE
370
, // [imgui-test only]
371
ImGuiItemStatusFlags_Openable = 1 << 10, //
372
ImGuiItemStatusFlags_Opened = 1 << 11, //
373
ImGuiItemStatusFlags_Checkable = 1 << 12, //
374
ImGuiItemStatusFlags_Checked = 1 << 13 //
378
// FIXME: this is in development, not exposed/functional as a generic feature yet.
379
// Horizontal/Vertical enums are fixed to 0/1 so they may be used to index ImVec2
380
enum ImGuiLayoutType_
382
ImGuiLayoutType_Horizontal = 0,
383
ImGuiLayoutType_Vertical = 1
386
// X/Y enums are fixed to 0/1 so they may be used to index ImVec2
397
ImGuiPlotType_Histogram
400
enum ImGuiInputSource
402
ImGuiInputSource_None = 0,
403
ImGuiInputSource_Mouse,
404
ImGuiInputSource_Nav,
405
ImGuiInputSource_NavKeyboard, // Only used occasionally for storage, not tested/handled by most code
406
ImGuiInputSource_NavGamepad, // "
407
ImGuiInputSource_COUNT
410
// FIXME-NAV: Clarify/expose various repeat delay/rate
411
enum ImGuiInputReadMode
413
ImGuiInputReadMode_Down,
414
ImGuiInputReadMode_Pressed,
415
ImGuiInputReadMode_Released,
416
ImGuiInputReadMode_Repeat,
417
ImGuiInputReadMode_RepeatSlow,
418
ImGuiInputReadMode_RepeatFast
421
enum ImGuiNavHighlightFlags_
423
ImGuiNavHighlightFlags_None = 0,
424
ImGuiNavHighlightFlags_TypeDefault = 1 << 0,
425
ImGuiNavHighlightFlags_TypeThin = 1 << 1,
426
ImGuiNavHighlightFlags_AlwaysDraw = 1 << 2, // Draw rectangular highlight if (g.NavId == id) _even_ when using the mouse.
427
ImGuiNavHighlightFlags_NoRounding = 1 << 3
430
enum ImGuiNavDirSourceFlags_
432
ImGuiNavDirSourceFlags_None = 0,
433
ImGuiNavDirSourceFlags_Keyboard = 1 << 0,
434
ImGuiNavDirSourceFlags_PadDPad = 1 << 1,
435
ImGuiNavDirSourceFlags_PadLStick = 1 << 2
438
enum ImGuiNavMoveFlags_
440
ImGuiNavMoveFlags_None = 0,
441
ImGuiNavMoveFlags_LoopX = 1 << 0, // On failed request, restart from opposite side
442
ImGuiNavMoveFlags_LoopY = 1 << 1,
443
ImGuiNavMoveFlags_WrapX = 1 << 2, // On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)
444
ImGuiNavMoveFlags_WrapY = 1 << 3, // This is not super useful for provided for completeness
445
ImGuiNavMoveFlags_AllowCurrentNavId = 1 << 4, // Allow scoring and considering the current NavId as a move target candidate. This is used when the move source is offset (e.g. pressing PageDown actually needs to send a Up move request, if we are pressing PageDown from the bottom-most item we need to stay in place)
446
ImGuiNavMoveFlags_AlsoScoreVisibleSet = 1 << 5 // Store alternate result in NavMoveResultLocalVisibleSet that only comprise elements that are already fully visible.
451
ImGuiNavForward_None,
452
ImGuiNavForward_ForwardQueued,
453
ImGuiNavForward_ForwardActive
458
ImGuiNavLayer_Main = 0, // Main scrolling layer
459
ImGuiNavLayer_Menu = 1, // Menu layer (access with Alt/ImGuiNavInput_Menu)
463
enum ImGuiPopupPositionPolicy
465
ImGuiPopupPositionPolicy_Default,
466
ImGuiPopupPositionPolicy_ComboBox
469
// 1D vector (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches)
473
ImVec1() { x = 0.0f; }
474
ImVec1(float _x) { x = _x; }
478
// 2D axis aligned bounding-box
479
// NB: we can't rely on ImVec2 math operators being available here
480
struct IMGUI_API ImRect
482
ImVec2 Min; // Upper-left
483
ImVec2 Max; // Lower-right
485
ImRect() : Min(FLT_MAX,FLT_MAX), Max(-FLT_MAX,-FLT_MAX) {}
486
ImRect(const ImVec2& min, const ImVec2& max) : Min(min), Max(max) {}
487
ImRect(const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {}
488
ImRect(float x1, float y1, float x2, float y2) : Min(x1, y1), Max(x2, y2) {}
490
ImVec2 GetCenter() const { return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
491
ImVec2 GetSize() const { return ImVec2(Max.x - Min.x, Max.y - Min.y); }
492
float GetWidth() const { return Max.x - Min.x; }
493
float GetHeight() const { return Max.y - Min.y; }
494
ImVec2 GetTL() const { return Min; } // Top-left
495
ImVec2 GetTR() const { return ImVec2(Max.x, Min.y); } // Top-right
496
ImVec2 GetBL() const { return ImVec2(Min.x, Max.y); } // Bottom-left
497
ImVec2 GetBR() const { return Max; } // Bottom-right
498
bool Contains(const ImVec2& p) const { return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; }
499
bool Contains(const ImRect& r) const { return r.Min.x >= Min.x && r.Min.y >= Min.y && r.Max.x <= Max.x && r.Max.y <= Max.y; }
500
bool Overlaps(const ImRect& r) const { return r.Min.y < Max.y && r.Max.y > Min.y && r.Min.x < Max.x && r.Max.x > Min.x; }
501
void Add(const ImVec2& p) { if (Min.x > p.x) Min.x = p.x; if (Min.y > p.y) Min.y = p.y; if (Max.x < p.x) Max.x = p.x; if (Max.y < p.y) Max.y = p.y; }
502
void Add(const ImRect& r) { if (Min.x > r.Min.x) Min.x = r.Min.x; if (Min.y > r.Min.y) Min.y = r.Min.y; if (Max.x < r.Max.x) Max.x = r.Max.x; if (Max.y < r.Max.y) Max.y = r.Max.y; }
503
void Expand(const float amount) { Min.x -= amount; Min.y -= amount; Max.x += amount; Max.y += amount; }
504
void Expand(const ImVec2& amount) { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
505
void Translate(const ImVec2& d) { Min.x += d.x; Min.y += d.y; Max.x += d.x; Max.y += d.y; }
506
void TranslateX(float dx) { Min.x += dx; Max.x += dx; }
507
void TranslateY(float dy) { Min.y += dy; Max.y += dy; }
508
void ClipWith(const ImRect& r) { Min = ImMax(Min, r.Min); Max = ImMin(Max, r.Max); } // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.
509
void ClipWithFull(const ImRect& r) { Min = ImClamp(Min, r.Min, r.Max); Max = ImClamp(Max, r.Min, r.Max); } // Full version, ensure both points are fully clipped.
510
void Floor() { Min.x = (float)(int)Min.x; Min.y = (float)(int)Min.y; Max.x = (float)(int)Max.x; Max.y = (float)(int)Max.y; }
511
bool IsInverted() const { return Min.x > Max.x || Min.y > Max.y; }
514
// Stacked color modifier, backup of modified data so we can restore it
521
// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
524
ImGuiStyleVar VarIdx;
525
union { int BackupInt[2]; float BackupFloat[2]; };
526
ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; }
527
ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; }
528
ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }
531
// Stacked storage data for BeginGroup()/EndGroup()
532
struct ImGuiGroupData
534
ImVec2 BackupCursorPos;
535
ImVec2 BackupCursorMaxPos;
537
ImVec1 BackupGroupOffset;
538
ImVec2 BackupCurrentLineSize;
539
float BackupCurrentLineTextBaseOffset;
540
float BackupLogLinePosY;
541
ImGuiID BackupActiveIdIsAlive;
542
bool BackupActiveIdPreviousFrameIsAlive;
546
// Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper.
547
struct IMGUI_API ImGuiMenuColumns
551
float Width, NextWidth;
552
float Pos[4], NextWidths[4];
555
void Update(int count, float spacing, bool clear);
556
float DeclColumns(float w0, float w1, float w2);
557
float CalcExtraSpace(float avail_w);
560
// Internal state of the currently focused/edited text input box
561
struct IMGUI_API ImGuiInputTextState
563
ImGuiID ID; // widget id owning the text state
564
ImVector<ImWchar> TextW; // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
565
ImVector<char> InitialText; // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
566
ImVector<char> TempBuffer; // temporary buffer for callback and other other operations. size=capacity.
567
int CurLenA, CurLenW; // we need to maintain our buffer length in both UTF-8 and wchar format.
568
int BufCapacityA; // end-user buffer capacity
570
ImGuiStb::STB_TexteditState StbState;
573
bool SelectedAllMouseLock;
575
// Temporarily set when active
576
ImGuiInputTextFlags UserFlags;
577
ImGuiInputTextCallback UserCallback;
578
void* UserCallbackData;
580
ImGuiInputTextState() { memset(this, 0, sizeof(*this)); }
581
void CursorAnimReset() { CursorAnim = -0.30f; } // After a user-input the cursor stays on for a while without blinking
582
void CursorClamp() { StbState.cursor = ImMin(StbState.cursor, CurLenW); StbState.select_start = ImMin(StbState.select_start, CurLenW); StbState.select_end = ImMin(StbState.select_end, CurLenW); }
583
bool HasSelection() const { return StbState.select_start != StbState.select_end; }
584
void ClearSelection() { StbState.select_start = StbState.select_end = StbState.cursor; }
585
void SelectAll() { StbState.select_start = 0; StbState.cursor = StbState.select_end = CurLenW; StbState.has_preferred_x = 0; }
586
void OnKeyPressed(int key); // Cannot be inline because we call in code in stb_textedit.h implementation
589
// Windows data saved in imgui.ini file
590
struct ImGuiWindowSettings
598
ImGuiWindowSettings() { Name = NULL; ID = 0; Pos = Size = ImVec2(0,0); Collapsed = false; }
601
struct ImGuiSettingsHandler
603
const char* TypeName; // Short description stored in .ini file. Disallowed characters: '[' ']'
604
ImGuiID TypeHash; // == ImHashStr(TypeName, 0, 0)
605
void* (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name); // Read: Called when entering into a new ini entry e.g. "[Window][Name]"
606
void (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line); // Read: Called for every line of text within an ini entry
607
void (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf); // Write: Output every entries into 'out_buf'
610
ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
613
// Storage for current popup stack
616
ImGuiID PopupId; // Set on OpenPopup()
617
ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
618
ImGuiWindow* ParentWindow; // Set on OpenPopup()
619
int OpenFrameCount; // Set on OpenPopup()
620
ImGuiID OpenParentId; // Set on OpenPopup(), we need this to differenciate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)
621
ImVec2 OpenPopupPos; // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
622
ImVec2 OpenMousePos; // Set on OpenPopup(), copy of mouse position at the time of opening popup
625
struct ImGuiColumnData
627
float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
628
float OffsetNormBeforeResize;
629
ImGuiColumnsFlags Flags; // Not exposed
632
ImGuiColumnData() { OffsetNorm = OffsetNormBeforeResize = 0.0f; Flags = 0; }
635
struct ImGuiColumnsSet
638
ImGuiColumnsFlags Flags;
644
float LineMinY, LineMaxY;
645
float StartPosY; // Copy of CursorPos
646
float StartMaxPosX; // Copy of CursorMaxPos
647
ImVector<ImGuiColumnData> Columns;
649
ImGuiColumnsSet() { Clear(); }
654
IsFirstFrame = false;
655
IsBeingResized = false;
659
LineMinY = LineMaxY = 0.0f;
666
// Data shared between all ImDrawList instances
667
struct IMGUI_API ImDrawListSharedData
669
ImVec2 TexUvWhitePixel; // UV of white pixel in the atlas
670
ImFont* Font; // Current/default font (optional, for simplified AddText overload)
671
float FontSize; // Current/default font size (optional, for simplified AddText overload)
672
float CurveTessellationTol;
673
ImVec4 ClipRectFullscreen; // Value for PushClipRectFullscreen()
676
// FIXME: Bake rounded corners fill/borders in atlas
677
ImVec2 CircleVtx12[12];
679
ImDrawListSharedData();
682
struct ImDrawDataBuilder
684
ImVector<ImDrawList*> Layers[2]; // Global layers for: regular, tooltip
686
void Clear() { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].resize(0); }
687
void ClearFreeMemory() { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].clear(); }
688
IMGUI_API void FlattenIntoSingleLayer();
691
struct ImGuiNavMoveResult
693
ImGuiID ID; // Best candidate
694
ImGuiID SelectScopeId;// Best candidate window current selectable group ID
695
ImGuiWindow* Window; // Best candidate window
696
float DistBox; // Best candidate box distance to current NavId
697
float DistCenter; // Best candidate center distance to current NavId
699
ImRect RectRel; // Best candidate bounding box in window relative space
701
ImGuiNavMoveResult() { Clear(); }
702
void Clear() { ID = SelectScopeId = 0; Window = NULL; DistBox = DistCenter = DistAxial = FLT_MAX; RectRel = ImRect(); }
705
// Storage for SetNexWindow** functions
706
struct ImGuiNextWindowData
710
ImGuiCond ContentSizeCond;
711
ImGuiCond CollapsedCond;
712
ImGuiCond SizeConstraintCond;
714
ImGuiCond BgAlphaCond;
718
ImVec2 ContentSizeVal;
720
ImRect SizeConstraintRect;
721
ImGuiSizeCallback SizeCallback;
722
void* SizeCallbackUserData;
724
ImVec2 MenuBarOffsetMinVal; // This is not exposed publicly, so we don't clear it.
726
ImGuiNextWindowData()
728
PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = BgAlphaCond = 0;
729
PosVal = PosPivotVal = SizeVal = ImVec2(0.0f, 0.0f);
730
ContentSizeVal = ImVec2(0.0f, 0.0f);
731
CollapsedVal = false;
732
SizeConstraintRect = ImRect();
734
SizeCallbackUserData = NULL;
735
BgAlphaVal = FLT_MAX;
736
MenuBarOffsetMinVal = ImVec2(0.0f, 0.0f);
741
PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = BgAlphaCond = 0;
745
//-----------------------------------------------------------------------------
747
//-----------------------------------------------------------------------------
749
struct ImGuiTabBarSortItem
755
//-----------------------------------------------------------------------------
756
// Main imgui context
757
//-----------------------------------------------------------------------------
762
bool FrameScopeActive; // Set by NewFrame(), cleared by EndFrame()
763
bool FrameScopePushedImplicitWindow; // Set by NewFrame(), cleared by EndFrame()
764
bool FontAtlasOwnedByContext; // Io.Fonts-> is owned by the ImGuiContext and will be destructed along with it.
767
ImFont* Font; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
768
float FontSize; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
769
float FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
770
ImDrawListSharedData DrawListSharedData;
775
int FrameCountRendered;
776
ImVector<ImGuiWindow*> Windows; // Windows, sorted in display order, back to front
777
ImVector<ImGuiWindow*> WindowsFocusOrder; // Windows, sorted in focus order, back to front
778
ImVector<ImGuiWindow*> WindowsSortBuffer;
779
ImVector<ImGuiWindow*> CurrentWindowStack;
780
ImGuiStorage WindowsById;
781
int WindowsActiveCount;
782
ImGuiWindow* CurrentWindow; // Being drawn into
783
ImGuiWindow* HoveredWindow; // Will catch mouse inputs
784
ImGuiWindow* HoveredRootWindow; // Will catch mouse inputs (for focus/move only)
785
ImGuiID HoveredId; // Hovered widget
786
bool HoveredIdAllowOverlap;
787
ImGuiID HoveredIdPreviousFrame;
788
float HoveredIdTimer; // Measure contiguous hovering time
789
float HoveredIdNotActiveTimer; // Measure contiguous hovering time where the item has not been active
790
ImGuiID ActiveId; // Active widget
791
ImGuiID ActiveIdPreviousFrame;
792
ImGuiID ActiveIdIsAlive; // Active widget has been seen this frame (we can't use a bool as the ActiveId may change within the frame)
794
bool ActiveIdIsJustActivated; // Set at the time of activation for one frame
795
bool ActiveIdAllowOverlap; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
796
bool ActiveIdHasBeenPressed; // Track whether the active id led to a press (this is to allow changing between PressOnClick and PressOnRelease without pressing twice). Used by range_select branch.
797
bool ActiveIdHasBeenEdited; // Was the value associated to the widget Edited over the course of the Active state.
798
bool ActiveIdPreviousFrameIsAlive;
799
bool ActiveIdPreviousFrameHasBeenEdited;
800
int ActiveIdAllowNavDirFlags; // Active widget allows using directional navigation (e.g. can activate a button and move away from it)
801
int ActiveIdBlockNavInputFlags;
802
ImVec2 ActiveIdClickOffset; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
803
ImGuiWindow* ActiveIdWindow;
804
ImGuiWindow* ActiveIdPreviousFrameWindow;
805
ImGuiInputSource ActiveIdSource; // Activating with mouse or nav (gamepad/keyboard)
806
ImGuiID LastActiveId; // Store the last non-zero ActiveId, useful for animation.
807
float LastActiveIdTimer; // Store the last non-zero ActiveId timer since the beginning of activation, useful for animation.
808
ImVec2 LastValidMousePos;
809
ImGuiWindow* MovingWindow; // Track the window we clicked on (in order to preserve focus). The actually window that is moved is generally MovingWindow->RootWindow.
810
ImVector<ImGuiColorMod> ColorModifiers; // Stack for PushStyleColor()/PopStyleColor()
811
ImVector<ImGuiStyleMod> StyleModifiers; // Stack for PushStyleVar()/PopStyleVar()
812
ImVector<ImFont*> FontStack; // Stack for PushFont()/PopFont()
813
ImVector<ImGuiPopupRef> OpenPopupStack; // Which popups are open (persistent)
814
ImVector<ImGuiPopupRef> BeginPopupStack; // Which level of BeginPopup() we are in (reset every frame)
815
ImGuiNextWindowData NextWindowData; // Storage for SetNextWindow** functions
816
bool NextTreeNodeOpenVal; // Storage for SetNextTreeNode** functions
817
ImGuiCond NextTreeNodeOpenCond;
819
// Navigation data (for gamepad/keyboard)
820
ImGuiWindow* NavWindow; // Focused window for navigation. Could be called 'FocusWindow'
821
ImGuiID NavId; // Focused item for navigation
822
ImGuiID NavActivateId; // ~~ (g.ActiveId == 0) && IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0, also set when calling ActivateItem()
823
ImGuiID NavActivateDownId; // ~~ IsNavInputDown(ImGuiNavInput_Activate) ? NavId : 0
824
ImGuiID NavActivatePressedId; // ~~ IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0
825
ImGuiID NavInputId; // ~~ IsNavInputPressed(ImGuiNavInput_Input) ? NavId : 0
826
ImGuiID NavJustTabbedId; // Just tabbed to this id.
827
ImGuiID NavJustMovedToId; // Just navigated to this id (result of a successfully MoveRequest).
828
ImGuiID NavJustMovedToSelectScopeId; // Just navigated to this select scope id (result of a successfully MoveRequest).
829
ImGuiID NavNextActivateId; // Set by ActivateItem(), queued until next frame.
830
ImGuiInputSource NavInputSource; // Keyboard or Gamepad mode? THIS WILL ONLY BE None or NavGamepad or NavKeyboard.
831
ImRect NavScoringRectScreen; // Rectangle used for scoring, in screen space. Based of window->DC.NavRefRectRel[], modified for directional navigation scoring.
832
int NavScoringCount; // Metrics for debugging
833
ImGuiWindow* NavWindowingTarget; // When selecting a window (holding Menu+FocusPrev/Next, or equivalent of CTRL-TAB) this window is temporarily displayed front-most.
834
ImGuiWindow* NavWindowingTargetAnim; // Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f
835
ImGuiWindow* NavWindowingList;
836
float NavWindowingTimer;
837
float NavWindowingHighlightAlpha;
838
bool NavWindowingToggleLayer;
839
ImGuiNavLayer NavLayer; // Layer we are navigating on. For now the system is hard-coded for 0=main contents and 1=menu/title bar, may expose layers later.
840
int NavIdTabCounter; // == NavWindow->DC.FocusIdxTabCounter at time of NavId processing
841
bool NavIdIsAlive; // Nav widget has been seen this frame ~~ NavRefRectRel is valid
842
bool NavMousePosDirty; // When set we will update mouse position if (io.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos) if set (NB: this not enabled by default)
843
bool NavDisableHighlight; // When user starts using mouse, we hide gamepad/keyboard highlight (NB: but they are still available, which is why NavDisableHighlight isn't always != NavDisableMouseHover)
844
bool NavDisableMouseHover; // When user starts using gamepad/keyboard, we hide mouse hovering highlight until mouse is touched again.
845
bool NavAnyRequest; // ~~ NavMoveRequest || NavInitRequest
846
bool NavInitRequest; // Init request for appearing window to select first item
847
bool NavInitRequestFromMove;
848
ImGuiID NavInitResultId;
849
ImRect NavInitResultRectRel;
850
bool NavMoveFromClampedRefRect; // Set by manual scrolling, if we scroll to a point where NavId isn't visible we reset navigation from visible items
851
bool NavMoveRequest; // Move request for this frame
852
ImGuiNavMoveFlags NavMoveRequestFlags;
853
ImGuiNavForward NavMoveRequestForward; // None / ForwardQueued / ForwardActive (this is used to navigate sibling parent menus from a child menu)
854
ImGuiDir NavMoveDir, NavMoveDirLast; // Direction of the move request (left/right/up/down), direction of the previous move request
855
ImGuiDir NavMoveClipDir;
856
ImGuiNavMoveResult NavMoveResultLocal; // Best move request candidate within NavWindow
857
ImGuiNavMoveResult NavMoveResultLocalVisibleSet; // Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag)
858
ImGuiNavMoveResult NavMoveResultOther; // Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag)
861
ImDrawData DrawData; // Main ImDrawData instance to pass render information to the user
862
ImDrawDataBuilder DrawDataBuilder;
863
float DimBgRatio; // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)
864
ImDrawList OverlayDrawList; // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays
865
ImGuiMouseCursor MouseCursor;
869
bool DragDropWithinSourceOrTarget;
870
ImGuiDragDropFlags DragDropSourceFlags;
871
int DragDropSourceFrameCount;
872
int DragDropMouseButton;
873
ImGuiPayload DragDropPayload;
874
ImRect DragDropTargetRect;
875
ImGuiID DragDropTargetId;
876
ImGuiDragDropFlags DragDropAcceptFlags;
877
float DragDropAcceptIdCurrRectSurface; // Target item surface (we resolve overlapping targets by prioritizing the smaller surface)
878
ImGuiID DragDropAcceptIdCurr; // Target item id (set at the time of accepting the payload)
879
ImGuiID DragDropAcceptIdPrev; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
880
int DragDropAcceptFrameCount; // Last time a target expressed a desire to accept the source
881
ImVector<unsigned char> DragDropPayloadBufHeap; // We don't expose the ImVector<> directly
882
unsigned char DragDropPayloadBufLocal[8]; // Local buffer for small payloads
885
ImPool<ImGuiTabBar> TabBars;
886
ImVector<ImGuiTabBar*> CurrentTabBar;
887
ImVector<ImGuiTabBarSortItem> TabSortByWidthBuffer;
890
ImGuiInputTextState InputTextState;
891
ImFont InputTextPasswordFont;
892
ImGuiID ScalarAsInputTextId; // Temporary text input when CTRL+clicking on a slider, etc.
893
ImGuiColorEditFlags ColorEditOptions; // Store user options for color edit widgets
894
ImVec4 ColorPickerRef;
895
bool DragCurrentAccumDirty;
896
float DragCurrentAccum; // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings
897
float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
898
ImVec2 ScrollbarClickDeltaToGrabCenter; // Distance between mouse and center of grab box, normalized in parent space. Use storage?
899
int TooltipOverrideCount;
900
ImVector<char> PrivateClipboard; // If no custom clipboard handler is defined
902
// Range-Select/Multi-Select
903
// [This is unused in this branch, but left here to facilitate merging/syncing multiple branches]
904
ImGuiID MultiSelectScopeId;
907
ImVec2 PlatformImePos; // Cursor position request & last passed to the OS Input Method Editor
908
ImVec2 PlatformImeLastPos;
912
float SettingsDirtyTimer; // Save .ini Settings to memory when time reaches zero
913
ImGuiTextBuffer SettingsIniData; // In memory .ini settings
914
ImVector<ImGuiSettingsHandler> SettingsHandlers; // List of .ini settings handlers
915
ImVector<ImGuiWindowSettings> SettingsWindows; // ImGuiWindow .ini settings entries (parsed from the last loaded .ini file and maintained on saving)
919
FILE* LogFile; // If != NULL log to stdout/ file
920
ImGuiTextBuffer LogClipboard; // Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
922
int LogAutoExpandMaxDepth;
925
float FramerateSecPerFrame[120]; // Calculate estimate of framerate for user over the last 2 seconds.
926
int FramerateSecPerFrameIdx;
927
float FramerateSecPerFrameAccum;
928
int WantCaptureMouseNextFrame; // Explicit capture via CaptureKeyboardFromApp()/CaptureMouseFromApp() sets those flags
929
int WantCaptureKeyboardNextFrame;
930
int WantTextInputNextFrame;
931
char TempBuffer[1024*3+1]; // Temporary text buffer
933
ImGuiContext(ImFontAtlas* shared_font_atlas) : OverlayDrawList(NULL)
936
FrameScopeActive = FrameScopePushedImplicitWindow = false;
938
FontSize = FontBaseSize = 0.0f;
939
FontAtlasOwnedByContext = shared_font_atlas ? false : true;
940
IO.Fonts = shared_font_atlas ? shared_font_atlas : IM_NEW(ImFontAtlas)();
944
FrameCountEnded = FrameCountRendered = -1;
945
WindowsActiveCount = 0;
946
CurrentWindow = NULL;
947
HoveredWindow = NULL;
948
HoveredRootWindow = NULL;
950
HoveredIdAllowOverlap = false;
951
HoveredIdPreviousFrame = 0;
952
HoveredIdTimer = HoveredIdNotActiveTimer = 0.0f;
954
ActiveIdPreviousFrame = 0;
956
ActiveIdTimer = 0.0f;
957
ActiveIdIsJustActivated = false;
958
ActiveIdAllowOverlap = false;
959
ActiveIdHasBeenPressed = false;
960
ActiveIdHasBeenEdited = false;
961
ActiveIdPreviousFrameIsAlive = false;
962
ActiveIdPreviousFrameHasBeenEdited = false;
963
ActiveIdAllowNavDirFlags = 0x00;
964
ActiveIdBlockNavInputFlags = 0x00;
965
ActiveIdClickOffset = ImVec2(-1,-1);
966
ActiveIdWindow = ActiveIdPreviousFrameWindow = NULL;
967
ActiveIdSource = ImGuiInputSource_None;
969
LastActiveIdTimer = 0.0f;
970
LastValidMousePos = ImVec2(0.0f, 0.0f);
972
NextTreeNodeOpenVal = false;
973
NextTreeNodeOpenCond = 0;
976
NavId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavInputId = 0;
977
NavJustTabbedId = NavJustMovedToId = NavJustMovedToSelectScopeId = NavNextActivateId = 0;
978
NavInputSource = ImGuiInputSource_None;
979
NavScoringRectScreen = ImRect();
981
NavWindowingTarget = NavWindowingTargetAnim = NavWindowingList = NULL;
982
NavWindowingTimer = NavWindowingHighlightAlpha = 0.0f;
983
NavWindowingToggleLayer = false;
984
NavLayer = ImGuiNavLayer_Main;
985
NavIdTabCounter = INT_MAX;
986
NavIdIsAlive = false;
987
NavMousePosDirty = false;
988
NavDisableHighlight = true;
989
NavDisableMouseHover = false;
990
NavAnyRequest = false;
991
NavInitRequest = false;
992
NavInitRequestFromMove = false;
994
NavMoveFromClampedRefRect = false;
995
NavMoveRequest = false;
996
NavMoveRequestFlags = 0;
997
NavMoveRequestForward = ImGuiNavForward_None;
998
NavMoveDir = NavMoveDirLast = NavMoveClipDir = ImGuiDir_None;
1001
OverlayDrawList._Data = &DrawListSharedData;
1002
OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging
1003
MouseCursor = ImGuiMouseCursor_Arrow;
1005
DragDropActive = DragDropWithinSourceOrTarget = false;
1006
DragDropSourceFlags = 0;
1007
DragDropSourceFrameCount = -1;
1008
DragDropMouseButton = -1;
1009
DragDropTargetId = 0;
1010
DragDropAcceptFlags = 0;
1011
DragDropAcceptIdCurrRectSurface = 0.0f;
1012
DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
1013
DragDropAcceptFrameCount = -1;
1014
memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal));
1016
ScalarAsInputTextId = 0;
1017
ColorEditOptions = ImGuiColorEditFlags__OptionsDefault;
1018
DragCurrentAccumDirty = false;
1019
DragCurrentAccum = 0.0f;
1020
DragSpeedDefaultRatio = 1.0f / 100.0f;
1021
ScrollbarClickDeltaToGrabCenter = ImVec2(0.0f, 0.0f);
1022
TooltipOverrideCount = 0;
1024
MultiSelectScopeId = 0;
1026
PlatformImePos = PlatformImeLastPos = ImVec2(FLT_MAX, FLT_MAX);
1028
SettingsLoaded = false;
1029
SettingsDirtyTimer = 0.0f;
1034
LogAutoExpandMaxDepth = 2;
1036
memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
1037
FramerateSecPerFrameIdx = 0;
1038
FramerateSecPerFrameAccum = 0.0f;
1039
WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
1040
memset(TempBuffer, 0, sizeof(TempBuffer));
1044
//-----------------------------------------------------------------------------
1046
//-----------------------------------------------------------------------------
1048
// Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow.
1049
// FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered.
1050
struct IMGUI_API ImGuiWindowTempData
1053
ImVec2 CursorPosPrevLine;
1054
ImVec2 CursorStartPos; // Initial position in client area with padding
1055
ImVec2 CursorMaxPos; // Used to implicitly calculate the size of our contents, always growing during the frame. Turned into window->SizeContents at the beginning of next frame
1056
ImVec2 CurrentLineSize;
1057
float CurrentLineTextBaseOffset;
1058
ImVec2 PrevLineSize;
1059
float PrevLineTextBaseOffset;
1062
ImU32 TreeDepthMayJumpToParentOnPop; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31
1064
ImGuiItemStatusFlags LastItemStatusFlags;
1065
ImRect LastItemRect; // Interaction rect
1066
ImRect LastItemDisplayRect; // End-user display rect (only valid if LastItemStatusFlags & ImGuiItemStatusFlags_HasDisplayRect)
1067
ImGuiNavLayer NavLayerCurrent; // Current layer, 0..31 (we currently only use 0..1)
1068
int NavLayerCurrentMask; // = (1 << NavLayerCurrent) used by ItemAdd prior to clipping.
1069
int NavLayerActiveMask; // Which layer have been written to (result from previous frame)
1070
int NavLayerActiveMaskNext; // Which layer have been written to (buffer for current frame)
1071
bool NavHideHighlightOneFrame;
1072
bool NavHasScroll; // Set when scrolling can be used (ScrollMax > 0.0f)
1073
bool MenuBarAppending; // FIXME: Remove this
1074
ImVec2 MenuBarOffset; // MenuBarOffset.x is sort of equivalent of a per-layer CursorPos.x, saved/restored as we switch to the menu bar. The only situation when MenuBarOffset.y is > 0 if when (SafeAreaPadding.y > FramePadding.y), often used on TVs.
1075
ImVector<ImGuiWindow*> ChildWindows;
1076
ImGuiStorage* StateStorage;
1077
ImGuiLayoutType LayoutType;
1078
ImGuiLayoutType ParentLayoutType; // Layout type of parent window at the time of Begin()
1080
// We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
1081
ImGuiItemFlags ItemFlags; // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default]
1082
float ItemWidth; // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
1083
float TextWrapPos; // == TextWrapPosStack.back() [empty == -1.0f]
1084
ImVector<ImGuiItemFlags>ItemFlagsStack;
1085
ImVector<float> ItemWidthStack;
1086
ImVector<float> TextWrapPosStack;
1087
ImVector<ImGuiGroupData>GroupStack;
1088
short StackSizesBackup[6]; // Store size of various stacks for asserting
1090
ImVec1 Indent; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
1092
ImVec1 ColumnsOffset; // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
1093
ImGuiColumnsSet* ColumnsSet; // Current columns set
1095
ImGuiWindowTempData()
1097
CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f);
1098
CurrentLineSize = PrevLineSize = ImVec2(0.0f, 0.0f);
1099
CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f;
1100
LogLinePosY = -1.0f;
1102
TreeDepthMayJumpToParentOnPop = 0x00;
1104
LastItemStatusFlags = 0;
1105
LastItemRect = LastItemDisplayRect = ImRect();
1106
NavLayerActiveMask = NavLayerActiveMaskNext = 0x00;
1107
NavLayerCurrent = ImGuiNavLayer_Main;
1108
NavLayerCurrentMask = (1 << ImGuiNavLayer_Main);
1109
NavHideHighlightOneFrame = false;
1110
NavHasScroll = false;
1111
MenuBarAppending = false;
1112
MenuBarOffset = ImVec2(0.0f, 0.0f);
1113
StateStorage = NULL;
1114
LayoutType = ParentLayoutType = ImGuiLayoutType_Vertical;
1116
ItemFlags = ImGuiItemFlags_Default_;
1117
TextWrapPos = -1.0f;
1118
memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
1120
Indent = ImVec1(0.0f);
1121
GroupOffset = ImVec1(0.0f);
1122
ColumnsOffset = ImVec1(0.0f);
1127
// Storage for one window
1128
struct IMGUI_API ImGuiWindow
1131
ImGuiID ID; // == ImHash(Name)
1132
ImGuiWindowFlags Flags; // See enum ImGuiWindowFlags_
1133
ImVec2 Pos; // Position (always rounded-up to nearest pixel)
1134
ImVec2 Size; // Current size (==SizeFull or collapsed title bar size)
1135
ImVec2 SizeFull; // Size when non collapsed
1136
ImVec2 SizeFullAtLastBegin; // Copy of SizeFull at the end of Begin. This is the reference value we'll use on the next frame to decide if we need scrollbars.
1137
ImVec2 SizeContents; // Size of contents (== extents reach of the drawing cursor) from previous frame. Include decoration, window title, border, menu, etc.
1138
ImVec2 SizeContentsExplicit; // Size of contents explicitly set by the user via SetNextWindowContentSize()
1139
ImVec2 WindowPadding; // Window padding at the time of begin.
1140
float WindowRounding; // Window rounding at the time of begin.
1141
float WindowBorderSize; // Window border size at the time of begin.
1142
int NameBufLen; // Size of buffer storing Name. May be larger than strlen(Name)!
1143
ImGuiID MoveId; // == window->GetID("#MOVE")
1144
ImGuiID ChildId; // ID of corresponding item in parent window (for navigation to return from child window to parent window)
1146
ImVec2 ScrollTarget; // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)
1147
ImVec2 ScrollTargetCenterRatio; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
1148
ImVec2 ScrollbarSizes; // Size taken by scrollbars on each axis
1149
bool ScrollbarX, ScrollbarY;
1150
bool Active; // Set to true on Begin(), unless Collapsed
1152
bool WriteAccessed; // Set to true when any widget access the current window
1153
bool Collapsed; // Set when collapsing window to become only title-bar
1154
bool WantCollapseToggle;
1155
bool SkipItems; // Set when items can safely be all clipped (e.g. window not visible or collapsed)
1156
bool Appearing; // Set during the frame where the window is appearing (or re-appearing)
1157
bool Hidden; // Do not display (== (HiddenFramesForResize > 0) ||
1158
bool HasCloseButton; // Set when the window has a close button (p_open != NULL)
1159
signed char ResizeBorderHeld; // Current border being held for resize (-1: none, otherwise 0-3)
1160
short BeginCount; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
1161
short BeginOrderWithinParent; // Order within immediate parent window, if we are a child window. Otherwise 0.
1162
short BeginOrderWithinContext; // Order within entire imgui context. This is mostly used for debugging submission order related issues.
1163
ImGuiID PopupId; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
1164
int AutoFitFramesX, AutoFitFramesY;
1165
bool AutoFitOnlyGrows;
1166
int AutoFitChildAxises;
1167
ImGuiDir AutoPosLastDirection;
1168
int HiddenFramesRegular; // Hide the window for N frames
1169
int HiddenFramesForResize; // Hide the window for N frames while allowing items to be submitted so we can measure their size
1170
ImGuiCond SetWindowPosAllowFlags; // store acceptable condition flags for SetNextWindowPos() use.
1171
ImGuiCond SetWindowSizeAllowFlags; // store acceptable condition flags for SetNextWindowSize() use.
1172
ImGuiCond SetWindowCollapsedAllowFlags; // store acceptable condition flags for SetNextWindowCollapsed() use.
1173
ImVec2 SetWindowPosVal; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
1174
ImVec2 SetWindowPosPivot; // store window pivot for positioning. ImVec2(0,0) when positioning from top-left corner; ImVec2(0.5f,0.5f) for centering; ImVec2(1,1) for bottom right.
1176
ImGuiWindowTempData DC; // Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the "DC" variable name.
1177
ImVector<ImGuiID> IDStack; // ID stack. ID are hashes seeded with the value at the top of the stack
1178
ImRect ClipRect; // Current clipping rectangle. = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2.
1179
ImRect OuterRectClipped; // = WindowRect just after setup in Begin(). == window->Rect() for root window.
1180
ImRect InnerMainRect, InnerClipRect;
1181
ImRect ContentsRegionRect; // FIXME: This is currently confusing/misleading. Maximum visible content position ~~ Pos + (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis
1182
int LastFrameActive; // Last frame number the window was Active.
1183
float ItemWidthDefault;
1184
ImGuiMenuColumns MenuColumns; // Simplified columns storage for menu items
1185
ImGuiStorage StateStorage;
1186
ImVector<ImGuiColumnsSet> ColumnsStorage;
1187
float FontWindowScale; // User scale multiplier per-window
1188
int SettingsIdx; // Index into SettingsWindow[] (indices are always valid as we only grow the array from the back)
1190
ImDrawList* DrawList; // == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer)
1191
ImDrawList DrawListInst;
1192
ImGuiWindow* ParentWindow; // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
1193
ImGuiWindow* RootWindow; // Point to ourself or first ancestor that is not a child window.
1194
ImGuiWindow* RootWindowForTitleBarHighlight; // Point to ourself or first ancestor which will display TitleBgActive color when this window is active.
1195
ImGuiWindow* RootWindowForNav; // Point to ourself or first ancestor which doesn't have the NavFlattened flag.
1197
ImGuiWindow* NavLastChildNavWindow; // When going to the menu bar, we remember the child window we came from. (This could probably be made implicit if we kept g.Windows sorted by last focused including child window.)
1198
ImGuiID NavLastIds[ImGuiNavLayer_COUNT]; // Last known NavId for this window, per layer (0/1)
1199
ImRect NavRectRel[ImGuiNavLayer_COUNT]; // Reference rectangle, in window relative space
1201
// Navigation / Focus
1202
// FIXME-NAV: Merge all this with the new Nav system, at least the request variables should be moved to ImGuiContext
1203
int FocusIdxAllCounter; // Start at -1 and increase as assigned via FocusItemRegister()
1204
int FocusIdxTabCounter; // (same, but only count widgets which you can Tab through)
1205
int FocusIdxAllRequestCurrent; // Item being requested for focus
1206
int FocusIdxTabRequestCurrent; // Tab-able item being requested for focus
1207
int FocusIdxAllRequestNext; // Item being requested for focus, for next update (relies on layout to be stable between the frame pressing TAB and the next frame)
1208
int FocusIdxTabRequestNext; // "
1211
ImGuiWindow(ImGuiContext* context, const char* name);
1214
ImGuiID GetID(const char* str, const char* str_end = NULL);
1215
ImGuiID GetID(const void* ptr);
1216
ImGuiID GetIDNoKeepAlive(const char* str, const char* str_end = NULL);
1217
ImGuiID GetIDNoKeepAlive(const void* ptr);
1218
ImGuiID GetIDFromRectangle(const ImRect& r_abs);
1220
// We don't use g.FontSize because the window may be != g.CurrentWidow.
1221
ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x+Size.x, Pos.y+Size.y); }
1222
float CalcFontSize() const { return GImGui->FontBaseSize * FontWindowScale; }
1223
float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f; }
1224
ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); }
1225
float MenuBarHeight() const { return (Flags & ImGuiWindowFlags_MenuBar) ? DC.MenuBarOffset.y + CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f : 0.0f; }
1226
ImRect MenuBarRect() const { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); }
1229
// Backup and restore just enough data to be able to use IsItemHovered() on item A after another B in the same window has overwritten the data.
1230
struct ImGuiItemHoveredDataBackup
1233
ImGuiItemStatusFlags LastItemStatusFlags;
1234
ImRect LastItemRect;
1235
ImRect LastItemDisplayRect;
1237
ImGuiItemHoveredDataBackup() { Backup(); }
1238
void Backup() { ImGuiWindow* window = GImGui->CurrentWindow; LastItemId = window->DC.LastItemId; LastItemStatusFlags = window->DC.LastItemStatusFlags; LastItemRect = window->DC.LastItemRect; LastItemDisplayRect = window->DC.LastItemDisplayRect; }
1239
void Restore() const { ImGuiWindow* window = GImGui->CurrentWindow; window->DC.LastItemId = LastItemId; window->DC.LastItemStatusFlags = LastItemStatusFlags; window->DC.LastItemRect = LastItemRect; window->DC.LastItemDisplayRect = LastItemDisplayRect; }
1242
//-----------------------------------------------------------------------------
1243
// Tab bar, tab item
1244
//-----------------------------------------------------------------------------
1246
enum ImGuiTabBarFlagsPrivate_
1248
ImGuiTabBarFlags_DockNode = 1 << 20, // Part of a dock node
1249
ImGuiTabBarFlags_IsFocused = 1 << 21,
1250
ImGuiTabBarFlags_SaveSettings = 1 << 22 // FIXME: Settings are handled by the docking system, this only request the tab bar to mark settings dirty when reordering tabs
1253
enum ImGuiTabItemFlagsPrivate_
1255
ImGuiTabItemFlags_NoCloseButton = 1 << 20 // Store whether p_open is set or not, which we need to recompute WidthContents during layout.
1258
// Storage for one active tab item (sizeof() 26~32 bytes)
1262
ImGuiTabItemFlags Flags;
1263
int LastFrameVisible;
1264
int LastFrameSelected; // This allows us to infer an ordered list of the last activated tabs with little maintenance
1265
int NameOffset; // When Window==NULL, offset to name within parent ImGuiTabBar::TabsNames
1266
float Offset; // Position relative to beginning of tab
1267
float Width; // Width currently displayed
1268
float WidthContents; // Width of actual contents, stored during BeginTabItem() call
1270
ImGuiTabItem() { ID = Flags = 0; LastFrameVisible = LastFrameSelected = -1; NameOffset = -1; Offset = Width = WidthContents = 0.0f; }
1273
// Storage for a tab bar (sizeof() 92~96 bytes)
1276
ImVector<ImGuiTabItem> Tabs;
1277
ImGuiID ID; // Zero for tab-bars used by docking
1278
ImGuiID SelectedTabId; // Selected tab
1279
ImGuiID NextSelectedTabId;
1280
ImGuiID VisibleTabId; // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)
1281
int CurrFrameVisible;
1282
int PrevFrameVisible;
1284
float ContentsHeight;
1285
float OffsetMax; // Distance from BarRect.Min.x, locked during layout
1286
float OffsetNextTab; // Distance from BarRect.Min.x, incremented with each BeginTabItem() call, not used if ImGuiTabBarFlags_Reorderable if set.
1287
float ScrollingAnim;
1288
float ScrollingTarget;
1289
ImGuiTabBarFlags Flags;
1290
ImGuiID ReorderRequestTabId;
1291
int ReorderRequestDir;
1293
bool VisibleTabWasSubmitted;
1294
short LastTabItemIdx; // For BeginTabItem()/EndTabItem()
1295
ImVec2 FramePadding; // style.FramePadding locked at the time of BeginTabBar()
1296
ImGuiTextBuffer TabsNames; // For non-docking tab bar we re-append names in a contiguous buffer.
1299
int GetTabOrder(const ImGuiTabItem* tab) const { return Tabs.index_from_ptr(tab); }
1300
const char* GetTabName(const ImGuiTabItem* tab) const
1302
IM_ASSERT(tab->NameOffset != -1 && tab->NameOffset < TabsNames.Buf.Size);
1303
return TabsNames.Buf.Data + tab->NameOffset;
1307
//-----------------------------------------------------------------------------
1309
// No guarantee of forward compatibility here.
1310
//-----------------------------------------------------------------------------
1314
// We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
1315
// If this ever crash because g.CurrentWindow is NULL it means that either
1316
// - ImGui::NewFrame() has never been called, which is illegal.
1317
// - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
1318
inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; }
1319
inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }
1320
IMGUI_API ImGuiWindow* FindWindowByID(ImGuiID id);
1321
IMGUI_API ImGuiWindow* FindWindowByName(const char* name);
1322
IMGUI_API void FocusWindow(ImGuiWindow* window);
1323
IMGUI_API void FocusPreviousWindowIgnoringOne(ImGuiWindow* ignore_window);
1324
IMGUI_API void BringWindowToFocusFront(ImGuiWindow* window);
1325
IMGUI_API void BringWindowToDisplayFront(ImGuiWindow* window);
1326
IMGUI_API void BringWindowToDisplayBack(ImGuiWindow* window);
1327
IMGUI_API void UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window);
1328
IMGUI_API ImVec2 CalcWindowExpectedSize(ImGuiWindow* window);
1329
IMGUI_API bool IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent);
1330
IMGUI_API bool IsWindowNavFocusable(ImGuiWindow* window);
1331
IMGUI_API void SetWindowScrollX(ImGuiWindow* window, float new_scroll_x);
1332
IMGUI_API void SetWindowScrollY(ImGuiWindow* window, float new_scroll_y);
1333
IMGUI_API float GetWindowScrollMaxX(ImGuiWindow* window);
1334
IMGUI_API float GetWindowScrollMaxY(ImGuiWindow* window);
1335
IMGUI_API ImRect GetWindowAllowedExtentRect(ImGuiWindow* window);
1336
IMGUI_API void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiCond cond);
1337
IMGUI_API void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond);
1338
IMGUI_API void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiCond cond);
1340
IMGUI_API void SetCurrentFont(ImFont* font);
1341
inline ImFont* GetDefaultFont() { ImGuiContext& g = *GImGui; return g.IO.FontDefault ? g.IO.FontDefault : g.IO.Fonts->Fonts[0]; }
1344
IMGUI_API void Initialize(ImGuiContext* context);
1345
IMGUI_API void Shutdown(ImGuiContext* context); // Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext().
1348
IMGUI_API void UpdateHoveredWindowAndCaptureFlags();
1349
IMGUI_API void StartMouseMovingWindow(ImGuiWindow* window);
1350
IMGUI_API void UpdateMouseMovingWindowNewFrame();
1351
IMGUI_API void UpdateMouseMovingWindowEndFrame();
1354
IMGUI_API void MarkIniSettingsDirty();
1355
IMGUI_API void MarkIniSettingsDirty(ImGuiWindow* window);
1356
IMGUI_API ImGuiWindowSettings* CreateNewWindowSettings(const char* name);
1357
IMGUI_API ImGuiWindowSettings* FindWindowSettings(ImGuiID id);
1358
IMGUI_API ImGuiWindowSettings* FindOrCreateWindowSettings(const char* name);
1359
IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(const char* type_name);
1362
inline ImGuiID GetItemID() { ImGuiContext& g = *GImGui; return g.CurrentWindow->DC.LastItemId; }
1363
inline ImGuiID GetActiveID() { ImGuiContext& g = *GImGui; return g.ActiveId; }
1364
inline ImGuiID GetFocusID() { ImGuiContext& g = *GImGui; return g.NavId; }
1365
IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow* window);
1366
IMGUI_API void SetFocusID(ImGuiID id, ImGuiWindow* window);
1367
IMGUI_API void ClearActiveID();
1368
IMGUI_API ImGuiID GetHoveredID();
1369
IMGUI_API void SetHoveredID(ImGuiID id);
1370
IMGUI_API void KeepAliveID(ImGuiID id);
1371
IMGUI_API void MarkItemEdited(ImGuiID id);
1373
// Basic Helpers for widget code
1374
IMGUI_API void ItemSize(const ImVec2& size, float text_offset_y = 0.0f);
1375
IMGUI_API void ItemSize(const ImRect& bb, float text_offset_y = 0.0f);
1376
IMGUI_API bool ItemAdd(const ImRect& bb, ImGuiID id, const ImRect* nav_bb = NULL);
1377
IMGUI_API bool ItemHoverable(const ImRect& bb, ImGuiID id);
1378
IMGUI_API bool IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged);
1379
IMGUI_API bool FocusableItemRegister(ImGuiWindow* window, ImGuiID id, bool tab_stop = true); // Return true if focus is requested
1380
IMGUI_API void FocusableItemUnregister(ImGuiWindow* window);
1381
IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_x, float default_y);
1382
IMGUI_API float CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
1383
IMGUI_API void PushMultiItemsWidths(int components, float width_full = 0.0f);
1384
IMGUI_API void PushItemFlag(ImGuiItemFlags option, bool enabled);
1385
IMGUI_API void PopItemFlag();
1387
// Popups, Modals, Tooltips
1388
IMGUI_API void OpenPopupEx(ImGuiID id);
1389
IMGUI_API void ClosePopupToLevel(int remaining, bool apply_focus_to_window_under);
1390
IMGUI_API void ClosePopupsOverWindow(ImGuiWindow* ref_window);
1391
IMGUI_API bool IsPopupOpen(ImGuiID id); // Test for id within current popup stack level (currently begin-ed into); this doesn't scan the whole popup stack!
1392
IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags);
1393
IMGUI_API void BeginTooltipEx(ImGuiWindowFlags extra_flags, bool override_previous_tooltip = true);
1394
IMGUI_API ImGuiWindow* GetFrontMostPopupModal();
1395
IMGUI_API ImVec2 FindBestWindowPosForPopup(ImGuiWindow* window);
1396
IMGUI_API ImVec2 FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy = ImGuiPopupPositionPolicy_Default);
1399
IMGUI_API void NavInitWindow(ImGuiWindow* window, bool force_reinit);
1400
IMGUI_API bool NavMoveRequestButNoResultYet();
1401
IMGUI_API void NavMoveRequestCancel();
1402
IMGUI_API void NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect& bb_rel, ImGuiNavMoveFlags move_flags);
1403
IMGUI_API void NavMoveRequestTryWrapping(ImGuiWindow* window, ImGuiNavMoveFlags move_flags);
1404
IMGUI_API float GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode);
1405
IMGUI_API ImVec2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor = 0.0f, float fast_factor = 0.0f);
1406
IMGUI_API int CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate);
1407
IMGUI_API void ActivateItem(ImGuiID id); // Remotely activate a button, checkbox, tree node etc. given its unique ID. activation is queued and processed on the next frame when the item is encountered again.
1408
IMGUI_API void SetNavID(ImGuiID id, int nav_layer);
1409
IMGUI_API void SetNavIDWithRectRel(ImGuiID id, int nav_layer, const ImRect& rect_rel);
1412
inline bool IsKeyPressedMap(ImGuiKey key, bool repeat = true) { const int key_index = GImGui->IO.KeyMap[key]; return (key_index >= 0) ? IsKeyPressed(key_index, repeat) : false; }
1413
inline bool IsNavInputDown(ImGuiNavInput n) { return GImGui->IO.NavInputs[n] > 0.0f; }
1414
inline bool IsNavInputPressed(ImGuiNavInput n, ImGuiInputReadMode mode) { return GetNavInputAmount(n, mode) > 0.0f; }
1415
inline bool IsNavInputPressedAnyOfTwo(ImGuiNavInput n1, ImGuiNavInput n2, ImGuiInputReadMode mode) { return (GetNavInputAmount(n1, mode) + GetNavInputAmount(n2, mode)) > 0.0f; }
1418
IMGUI_API bool BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
1419
IMGUI_API void ClearDragDrop();
1420
IMGUI_API bool IsDragDropPayloadBeingAccepted();
1422
// New Columns API (FIXME-WIP)
1423
IMGUI_API void BeginColumns(const char* str_id, int count, ImGuiColumnsFlags flags = 0); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
1424
IMGUI_API void EndColumns(); // close columns
1425
IMGUI_API void PushColumnClipRect(int column_index = -1);
1428
IMGUI_API bool BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& bb, ImGuiTabBarFlags flags);
1429
IMGUI_API ImGuiTabItem* TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id);
1430
IMGUI_API void TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id);
1431
IMGUI_API void TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
1432
IMGUI_API void TabBarQueueChangeTabOrder(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, int dir);
1433
IMGUI_API bool TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags);
1434
IMGUI_API ImVec2 TabItemCalcSize(const char* label, bool has_close_button);
1435
IMGUI_API void TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col);
1436
IMGUI_API bool TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id);
1439
// AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.
1440
// NB: All position are in absolute pixels coordinates (we are never using window coordinates internally)
1441
IMGUI_API void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
1442
IMGUI_API void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
1443
IMGUI_API void RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0,0), const ImRect* clip_rect = NULL);
1444
IMGUI_API void RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
1445
IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f);
1446
IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f);
1447
IMGUI_API void RenderColorRectWithAlphaCheckerboard(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, int rounding_corners_flags = ~0);
1448
IMGUI_API void RenderArrow(ImVec2 pos, ImGuiDir dir, float scale = 1.0f);
1449
IMGUI_API void RenderBullet(ImVec2 pos);
1450
IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col, float sz);
1451
IMGUI_API void RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags = ImGuiNavHighlightFlags_TypeDefault); // Navigation highlight
1452
IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
1453
IMGUI_API void LogRenderedText(const ImVec2* ref_pos, const char* text, const char* text_end = NULL);
1455
// Render helpers (those functions don't access any ImGui state!)
1456
IMGUI_API void RenderMouseCursor(ImDrawList* draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor = ImGuiMouseCursor_Arrow);
1457
IMGUI_API void RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col);
1458
IMGUI_API void RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
1459
IMGUI_API void RenderPixelEllipsis(ImDrawList* draw_list, ImVec2 pos, int count, ImU32 col);
1462
IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0,0), ImGuiButtonFlags flags = 0);
1463
IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos, float radius);
1464
IMGUI_API bool CollapseButton(ImGuiID id, const ImVec2& pos);
1465
IMGUI_API bool ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags);
1466
IMGUI_API void Scrollbar(ImGuiLayoutType direction);
1467
IMGUI_API ImGuiID GetScrollbarID(ImGuiLayoutType direction);
1468
IMGUI_API void VerticalSeparator(); // Vertical separator, for menu bars (use current line height). Not exposed because it is misleading and it doesn't have an effect on regular layout.
1470
// Widgets low-level behaviors
1471
IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
1472
IMGUI_API bool DragBehavior(ImGuiID id, ImGuiDataType data_type, void* v, float v_speed, const void* v_min, const void* v_max, const char* format, float power, ImGuiDragFlags flags);
1473
IMGUI_API bool SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* v, const void* v_min, const void* v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb);
1474
IMGUI_API bool SplitterBehavior(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f, float hover_visibility_delay = 0.0f);
1475
IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL);
1476
IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0); // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging
1477
IMGUI_API void TreePushRawID(ImGuiID id);
1479
// Template functions are instantiated in imgui_widgets.cpp for a finite number of types.
1480
// To use them externally (for custom widget) you may need an "extern template" statement in your code in order to link to existing instances and silence Clang warnings (see #2036).
1481
// e.g. " extern template IMGUI_API float RoundScalarWithFormatT<float, float>(const char* format, ImGuiDataType data_type, float v); "
1482
template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool DragBehaviorT(ImGuiDataType data_type, T* v, float v_speed, const T v_min, const T v_max, const char* format, float power, ImGuiDragFlags flags);
1483
template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, T* v, const T v_min, const T v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb);
1484
template<typename T, typename FLOAT_T> IMGUI_API float SliderCalcRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, float power, float linear_zero_pos);
1485
template<typename T, typename SIGNED_T> IMGUI_API T RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, T v);
1488
IMGUI_API bool InputTextEx(const char* label, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
1489
IMGUI_API bool InputScalarAsWidgetReplacement(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* data_ptr, const char* format);
1492
IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
1493
IMGUI_API void ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
1494
IMGUI_API void ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags);
1497
IMGUI_API void PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 frame_size);
1499
// Shade functions (write over already created vertices)
1500
IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
1501
IMGUI_API void ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp);
1503
} // namespace ImGui
1505
// ImFontAtlas internals
1506
IMGUI_API bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas);
1507
IMGUI_API void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas* atlas);
1508
IMGUI_API void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent);
1509
IMGUI_API void ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* stbrp_context_opaque);
1510
IMGUI_API void ImFontAtlasBuildFinish(ImFontAtlas* atlas);
1511
IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor);
1512
IMGUI_API void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride);
1514
// Test engine hooks (imgui-test)
1515
//#define IMGUI_ENABLE_TEST_ENGINE
1516
#ifdef IMGUI_ENABLE_TEST_ENGINE
1517
extern void ImGuiTestEngineHook_PreNewFrame(ImGuiContext* ctx);
1518
extern void ImGuiTestEngineHook_PostNewFrame(ImGuiContext* ctx);
1519
extern void ImGuiTestEngineHook_ItemAdd(ImGuiContext* ctx, const ImRect& bb, ImGuiID id);
1520
extern void ImGuiTestEngineHook_ItemInfo(ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags);
1521
#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS) ImGuiTestEngineHook_ItemInfo(&g, _ID, _LABEL, _FLAGS) // Register status flags
1523
#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS) do { } while (0)
1527
#pragma clang diagnostic pop
1531
#pragma warning (pop)
added
removed
src/imgui/imgui_internal.h
