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