imgui_internal.h (47750B)
1 // dear imgui, v1.50 2 // (internals) 3 4 // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility! 5 // Implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators) 6 // #define IMGUI_DEFINE_MATH_OPERATORS 7 8 #pragma once 9 10 #ifndef IMGUI_VERSION 11 #error Must include imgui.h before imgui_internal.h 12 #endif 13 14 #include <stdio.h> // FILE* 15 #include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf 16 17 #ifdef _MSC_VER 18 #pragma warning (push) 19 #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) 20 #endif 21 22 #ifdef __clang__ 23 #pragma clang diagnostic push 24 #pragma clang diagnostic ignored "-Wunused-function" // for stb_textedit.h 25 #pragma clang diagnostic ignored "-Wmissing-prototypes" // for stb_textedit.h 26 #pragma clang diagnostic ignored "-Wold-style-cast" 27 #endif 28 29 //----------------------------------------------------------------------------- 30 // Forward Declarations 31 //----------------------------------------------------------------------------- 32 33 struct ImRect; 34 struct ImGuiColMod; 35 struct ImGuiStyleMod; 36 struct ImGuiGroupData; 37 struct ImGuiSimpleColumns; 38 struct ImGuiDrawContext; 39 struct ImGuiTextEditState; 40 struct ImGuiIniData; 41 struct ImGuiMouseCursorData; 42 struct ImGuiPopupRef; 43 struct ImGuiWindow; 44 45 typedef int ImGuiLayoutType; // enum ImGuiLayoutType_ 46 typedef int ImGuiButtonFlags; // enum ImGuiButtonFlags_ 47 typedef int ImGuiTreeNodeFlags; // enum ImGuiTreeNodeFlags_ 48 typedef int ImGuiSliderFlags; // enum ImGuiSliderFlags_ 49 50 //------------------------------------------------------------------------- 51 // STB libraries 52 //------------------------------------------------------------------------- 53 54 namespace ImGuiStb 55 { 56 57 #undef STB_TEXTEDIT_STRING 58 #undef STB_TEXTEDIT_CHARTYPE 59 #define STB_TEXTEDIT_STRING ImGuiTextEditState 60 #define STB_TEXTEDIT_CHARTYPE ImWchar 61 #define STB_TEXTEDIT_GETWIDTH_NEWLINE -1.0f 62 #include "stb_textedit.h" 63 64 } // namespace ImGuiStb 65 66 //----------------------------------------------------------------------------- 67 // Context 68 //----------------------------------------------------------------------------- 69 70 #ifndef GImGui 71 extern IMGUI_API ImGuiContext* GImGui; // Current implicit ImGui context pointer 72 #endif 73 74 //----------------------------------------------------------------------------- 75 // Helpers 76 //----------------------------------------------------------------------------- 77 78 #define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR)/sizeof(*_ARR))) 79 #define IM_PI 3.14159265358979323846f 80 #define IM_OFFSETOF(_TYPE,_ELM) ((size_t)&(((_TYPE*)0)->_ELM)) 81 82 // Helpers: UTF-8 <> wchar 83 IMGUI_API int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count 84 IMGUI_API int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // return input UTF-8 bytes count 85 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 86 IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count) 87 IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string as UTF-8 code-points 88 89 // Helpers: Misc 90 IMGUI_API ImU32 ImHash(const void* data, int data_size, ImU32 seed = 0); // Pass data_size==0 for zero-terminated strings 91 IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* file_open_mode, int* out_file_size = NULL, int padding_bytes = 0); 92 IMGUI_API FILE* ImFileOpen(const char* filename, const char* file_open_mode); 93 IMGUI_API bool ImIsPointInTriangle(const ImVec2& p, const ImVec2& a, const ImVec2& b, const ImVec2& c); 94 static inline bool ImCharIsSpace(int c) { return c == ' ' || c == '\t' || c == 0x3000; } 95 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; } 96 97 // Helpers: String 98 IMGUI_API int ImStricmp(const char* str1, const char* str2); 99 IMGUI_API int ImStrnicmp(const char* str1, const char* str2, int count); 100 IMGUI_API char* ImStrdup(const char* str); 101 IMGUI_API int ImStrlenW(const ImWchar* str); 102 IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line 103 IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end); 104 IMGUI_API int ImFormatString(char* buf, int buf_size, const char* fmt, ...) IM_PRINTFARGS(3); 105 IMGUI_API int ImFormatStringV(char* buf, int buf_size, const char* fmt, va_list args); 106 107 // Helpers: Math 108 // We are keeping those not leaking to the user by default, in the case the user has implicit cast operators between ImVec2 and its own types (when IM_VEC2_CLASS_EXTRA is defined) 109 #ifdef IMGUI_DEFINE_MATH_OPERATORS 110 static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x*rhs, lhs.y*rhs); } 111 static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x/rhs, lhs.y/rhs); } 112 static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x+rhs.x, lhs.y+rhs.y); } 113 static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x-rhs.x, lhs.y-rhs.y); } 114 static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x*rhs.x, lhs.y*rhs.y); } 115 static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x/rhs.x, lhs.y/rhs.y); } 116 static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs) { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; } 117 static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs) { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; } 118 static inline ImVec2& operator*=(ImVec2& lhs, const float rhs) { lhs.x *= rhs; lhs.y *= rhs; return lhs; } 119 static inline ImVec2& operator/=(ImVec2& lhs, const float rhs) { lhs.x /= rhs; lhs.y /= rhs; return lhs; } 120 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); } 121 #endif 122 123 static inline int ImMin(int lhs, int rhs) { return lhs < rhs ? lhs : rhs; } 124 static inline int ImMax(int lhs, int rhs) { return lhs >= rhs ? lhs : rhs; } 125 static inline float ImMin(float lhs, float rhs) { return lhs < rhs ? lhs : rhs; } 126 static inline float ImMax(float lhs, float rhs) { return lhs >= rhs ? lhs : rhs; } 127 static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(ImMin(lhs.x,rhs.x), ImMin(lhs.y,rhs.y)); } 128 static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(ImMax(lhs.x,rhs.x), ImMax(lhs.y,rhs.y)); } 129 static inline int ImClamp(int v, int mn, int mx) { return (v < mn) ? mn : (v > mx) ? mx : v; } 130 static inline float ImClamp(float v, float mn, float mx) { return (v < mn) ? mn : (v > mx) ? mx : v; } 131 static inline ImVec2 ImClamp(const ImVec2& f, const ImVec2& mn, ImVec2 mx) { return ImVec2(ImClamp(f.x,mn.x,mx.x), ImClamp(f.y,mn.y,mx.y)); } 132 static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; } 133 static inline float ImLerp(float a, float b, float t) { return a + (b - a) * t; } 134 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); } 135 static inline float ImLengthSqr(const ImVec2& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y; } 136 static inline float ImLengthSqr(const ImVec4& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y + lhs.z*lhs.z + lhs.w*lhs.w; } 137 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 / sqrtf(d); return fail_value; } 138 static inline float ImFloor(float f) { return (float)(int)f; } 139 static inline ImVec2 ImFloor(ImVec2 v) { return ImVec2((float)(int)v.x, (float)(int)v.y); } 140 141 // We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax. 142 // Defining a custom placement new() with a dummy parameter allows us to bypass including <new> which on some platforms complains when user has disabled exceptions. 143 #ifdef IMGUI_DEFINE_PLACEMENT_NEW 144 struct ImPlacementNewDummy {}; 145 inline void* operator new(size_t, ImPlacementNewDummy, void* ptr) { return ptr; } 146 inline void operator delete(void*, ImPlacementNewDummy, void*) {} 147 #define IM_PLACEMENT_NEW(_PTR) new(ImPlacementNewDummy(), _PTR) 148 #endif 149 150 //----------------------------------------------------------------------------- 151 // Types 152 //----------------------------------------------------------------------------- 153 154 enum ImGuiButtonFlags_ 155 { 156 ImGuiButtonFlags_Repeat = 1 << 0, // hold to repeat 157 ImGuiButtonFlags_PressedOnClickRelease = 1 << 1, // (default) return pressed on click+release on same item (default if no PressedOn** flag is set) 158 ImGuiButtonFlags_PressedOnClick = 1 << 2, // return pressed on click (default requires click+release) 159 ImGuiButtonFlags_PressedOnRelease = 1 << 3, // return pressed on release (default requires click+release) 160 ImGuiButtonFlags_PressedOnDoubleClick = 1 << 4, // return pressed on double-click (default requires click+release) 161 ImGuiButtonFlags_FlattenChilds = 1 << 5, // allow interaction even if a child window is overlapping 162 ImGuiButtonFlags_DontClosePopups = 1 << 6, // disable automatically closing parent popup on press 163 ImGuiButtonFlags_Disabled = 1 << 7, // disable interaction 164 ImGuiButtonFlags_AlignTextBaseLine = 1 << 8, // vertically align button to match text baseline - ButtonEx() only 165 ImGuiButtonFlags_NoKeyModifiers = 1 << 9, // disable interaction if a key modifier is held 166 ImGuiButtonFlags_AllowOverlapMode = 1 << 10 // require previous frame HoveredId to either match id or be null before being usable 167 }; 168 169 enum ImGuiSliderFlags_ 170 { 171 ImGuiSliderFlags_Vertical = 1 << 0 172 }; 173 174 enum ImGuiSelectableFlagsPrivate_ 175 { 176 // NB: need to be in sync with last value of ImGuiSelectableFlags_ 177 ImGuiSelectableFlags_Menu = 1 << 3, 178 ImGuiSelectableFlags_MenuItem = 1 << 4, 179 ImGuiSelectableFlags_Disabled = 1 << 5, 180 ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 6 181 }; 182 183 // FIXME: this is in development, not exposed/functional as a generic feature yet. 184 enum ImGuiLayoutType_ 185 { 186 ImGuiLayoutType_Vertical, 187 ImGuiLayoutType_Horizontal 188 }; 189 190 enum ImGuiPlotType 191 { 192 ImGuiPlotType_Lines, 193 ImGuiPlotType_Histogram 194 }; 195 196 enum ImGuiDataType 197 { 198 ImGuiDataType_Int, 199 ImGuiDataType_Float, 200 ImGuiDataType_Float2, 201 }; 202 203 enum ImGuiCorner 204 { 205 ImGuiCorner_TopLeft = 1 << 0, // 1 206 ImGuiCorner_TopRight = 1 << 1, // 2 207 ImGuiCorner_BottomRight = 1 << 2, // 4 208 ImGuiCorner_BottomLeft = 1 << 3, // 8 209 ImGuiCorner_All = 0x0F 210 }; 211 212 // 2D axis aligned bounding-box 213 // NB: we can't rely on ImVec2 math operators being available here 214 struct IMGUI_API ImRect 215 { 216 ImVec2 Min; // Upper-left 217 ImVec2 Max; // Lower-right 218 219 ImRect() : Min(FLT_MAX,FLT_MAX), Max(-FLT_MAX,-FLT_MAX) {} 220 ImRect(const ImVec2& min, const ImVec2& max) : Min(min), Max(max) {} 221 ImRect(const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {} 222 ImRect(float x1, float y1, float x2, float y2) : Min(x1, y1), Max(x2, y2) {} 223 224 ImVec2 GetCenter() const { return ImVec2((Min.x+Max.x)*0.5f, (Min.y+Max.y)*0.5f); } 225 ImVec2 GetSize() const { return ImVec2(Max.x-Min.x, Max.y-Min.y); } 226 float GetWidth() const { return Max.x-Min.x; } 227 float GetHeight() const { return Max.y-Min.y; } 228 ImVec2 GetTL() const { return Min; } // Top-left 229 ImVec2 GetTR() const { return ImVec2(Max.x, Min.y); } // Top-right 230 ImVec2 GetBL() const { return ImVec2(Min.x, Max.y); } // Bottom-left 231 ImVec2 GetBR() const { return Max; } // Bottom-right 232 bool Contains(const ImVec2& p) const { return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; } 233 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; } 234 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; } 235 void Add(const ImVec2& rhs) { if (Min.x > rhs.x) Min.x = rhs.x; if (Min.y > rhs.y) Min.y = rhs.y; if (Max.x < rhs.x) Max.x = rhs.x; if (Max.y < rhs.y) Max.y = rhs.y; } 236 void Add(const ImRect& rhs) { if (Min.x > rhs.Min.x) Min.x = rhs.Min.x; if (Min.y > rhs.Min.y) Min.y = rhs.Min.y; if (Max.x < rhs.Max.x) Max.x = rhs.Max.x; if (Max.y < rhs.Max.y) Max.y = rhs.Max.y; } 237 void Expand(const float amount) { Min.x -= amount; Min.y -= amount; Max.x += amount; Max.y += amount; } 238 void Expand(const ImVec2& amount) { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; } 239 void Reduce(const ImVec2& amount) { Min.x += amount.x; Min.y += amount.y; Max.x -= amount.x; Max.y -= amount.y; } 240 void Clip(const ImRect& clip) { if (Min.x < clip.Min.x) Min.x = clip.Min.x; if (Min.y < clip.Min.y) Min.y = clip.Min.y; if (Max.x > clip.Max.x) Max.x = clip.Max.x; if (Max.y > clip.Max.y) Max.y = clip.Max.y; } 241 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; } 242 ImVec2 GetClosestPoint(ImVec2 p, bool on_edge) const 243 { 244 if (!on_edge && Contains(p)) 245 return p; 246 if (p.x > Max.x) p.x = Max.x; 247 else if (p.x < Min.x) p.x = Min.x; 248 if (p.y > Max.y) p.y = Max.y; 249 else if (p.y < Min.y) p.y = Min.y; 250 return p; 251 } 252 }; 253 254 // Stacked color modifier, backup of modified data so we can restore it 255 struct ImGuiColMod 256 { 257 ImGuiCol Col; 258 ImVec4 BackupValue; 259 }; 260 261 // Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable. 262 struct ImGuiStyleMod 263 { 264 ImGuiStyleVar VarIdx; 265 union { int BackupInt[2]; float BackupFloat[2]; }; 266 ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; } 267 ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; } 268 ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; } 269 }; 270 271 // Stacked data for BeginGroup()/EndGroup() 272 struct ImGuiGroupData 273 { 274 ImVec2 BackupCursorPos; 275 ImVec2 BackupCursorMaxPos; 276 float BackupIndentX; 277 float BackupGroupOffsetX; 278 float BackupCurrentLineHeight; 279 float BackupCurrentLineTextBaseOffset; 280 float BackupLogLinePosY; 281 bool BackupActiveIdIsAlive; 282 bool AdvanceCursor; 283 }; 284 285 // Per column data for Columns() 286 struct ImGuiColumnData 287 { 288 float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right) 289 //float IndentX; 290 }; 291 292 // Simple column measurement currently used for MenuItem() only. This is very short-sighted/throw-away code and NOT a generic helper. 293 struct IMGUI_API ImGuiSimpleColumns 294 { 295 int Count; 296 float Spacing; 297 float Width, NextWidth; 298 float Pos[8], NextWidths[8]; 299 300 ImGuiSimpleColumns(); 301 void Update(int count, float spacing, bool clear); 302 float DeclColumns(float w0, float w1, float w2); 303 float CalcExtraSpace(float avail_w); 304 }; 305 306 // Internal state of the currently focused/edited text input box 307 struct IMGUI_API ImGuiTextEditState 308 { 309 ImGuiID Id; // widget id owning the text state 310 ImVector<ImWchar> Text; // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer. 311 ImVector<char> InitialText; // backup of end-user buffer at the time of focus (in UTF-8, unaltered) 312 ImVector<char> TempTextBuffer; 313 int CurLenA, CurLenW; // we need to maintain our buffer length in both UTF-8 and wchar format. 314 int BufSizeA; // end-user buffer size 315 float ScrollX; 316 ImGuiStb::STB_TexteditState StbState; 317 float CursorAnim; 318 bool CursorFollow; 319 bool SelectedAllMouseLock; 320 321 ImGuiTextEditState() { memset(this, 0, sizeof(*this)); } 322 void CursorAnimReset() { CursorAnim = -0.30f; } // After a user-input the cursor stays on for a while without blinking 323 void CursorClamp() { StbState.cursor = ImMin(StbState.cursor, CurLenW); StbState.select_start = ImMin(StbState.select_start, CurLenW); StbState.select_end = ImMin(StbState.select_end, CurLenW); } 324 bool HasSelection() const { return StbState.select_start != StbState.select_end; } 325 void ClearSelection() { StbState.select_start = StbState.select_end = StbState.cursor; } 326 void SelectAll() { StbState.select_start = 0; StbState.select_end = CurLenW; StbState.cursor = StbState.select_end; StbState.has_preferred_x = false; } 327 void OnKeyPressed(int key); 328 }; 329 330 // Data saved in imgui.ini file 331 struct ImGuiIniData 332 { 333 char* Name; 334 ImGuiID Id; 335 ImVec2 Pos; 336 ImVec2 Size; 337 bool Collapsed; 338 }; 339 340 // Mouse cursor data (used when io.MouseDrawCursor is set) 341 struct ImGuiMouseCursorData 342 { 343 ImGuiMouseCursor Type; 344 ImVec2 HotOffset; 345 ImVec2 Size; 346 ImVec2 TexUvMin[2]; 347 ImVec2 TexUvMax[2]; 348 }; 349 350 // Storage for current popup stack 351 struct ImGuiPopupRef 352 { 353 ImGuiID PopupId; // Set on OpenPopup() 354 ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup() 355 ImGuiWindow* ParentWindow; // Set on OpenPopup() 356 ImGuiID ParentMenuSet; // Set on OpenPopup() 357 ImVec2 MousePosOnOpen; // Copy of mouse position at the time of opening popup 358 359 ImGuiPopupRef(ImGuiID id, ImGuiWindow* parent_window, ImGuiID parent_menu_set, const ImVec2& mouse_pos) { PopupId = id; Window = NULL; ParentWindow = parent_window; ParentMenuSet = parent_menu_set; MousePosOnOpen = mouse_pos; } 360 }; 361 362 // Main state for ImGui 363 struct ImGuiContext 364 { 365 bool Initialized; 366 ImGuiIO IO; 367 ImGuiStyle Style; 368 ImFont* Font; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back() 369 float FontSize; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize() 370 float FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Size of characters. 371 ImVec2 FontTexUvWhitePixel; // (Shortcut) == Font->TexUvWhitePixel 372 373 float Time; 374 int FrameCount; 375 int FrameCountEnded; 376 int FrameCountRendered; 377 ImVector<ImGuiWindow*> Windows; 378 ImVector<ImGuiWindow*> WindowsSortBuffer; 379 ImGuiWindow* CurrentWindow; // Being drawn into 380 ImVector<ImGuiWindow*> CurrentWindowStack; 381 ImGuiWindow* FocusedWindow; // Will catch keyboard inputs 382 ImGuiWindow* HoveredWindow; // Will catch mouse inputs 383 ImGuiWindow* HoveredRootWindow; // Will catch mouse inputs (for focus/move only) 384 ImGuiID HoveredId; // Hovered widget 385 bool HoveredIdAllowOverlap; 386 ImGuiID HoveredIdPreviousFrame; 387 ImGuiID ActiveId; // Active widget 388 ImGuiID ActiveIdPreviousFrame; 389 bool ActiveIdIsAlive; 390 bool ActiveIdIsJustActivated; // Set at the time of activation for one frame 391 bool ActiveIdAllowOverlap; // Set only by active widget 392 ImVec2 ActiveIdClickOffset; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior) 393 ImGuiWindow* ActiveIdWindow; 394 ImGuiWindow* MovedWindow; // Track the child window we clicked on to move a window. 395 ImGuiID MovedWindowMoveId; // == MovedWindow->RootWindow->MoveId 396 ImVector<ImGuiIniData> Settings; // .ini Settings 397 float SettingsDirtyTimer; // Save .ini Settings on disk when time reaches zero 398 ImVector<ImGuiColMod> ColorModifiers; // Stack for PushStyleColor()/PopStyleColor() 399 ImVector<ImGuiStyleMod> StyleModifiers; // Stack for PushStyleVar()/PopStyleVar() 400 ImVector<ImFont*> FontStack; // Stack for PushFont()/PopFont() 401 ImVector<ImGuiPopupRef> OpenPopupStack; // Which popups are open (persistent) 402 ImVector<ImGuiPopupRef> CurrentPopupStack; // Which level of BeginPopup() we are in (reset every frame) 403 404 // Storage for SetNexWindow** and SetNextTreeNode*** functions 405 ImVec2 SetNextWindowPosVal; 406 ImVec2 SetNextWindowSizeVal; 407 ImVec2 SetNextWindowContentSizeVal; 408 bool SetNextWindowCollapsedVal; 409 ImGuiSetCond SetNextWindowPosCond; 410 ImGuiSetCond SetNextWindowSizeCond; 411 ImGuiSetCond SetNextWindowContentSizeCond; 412 ImGuiSetCond SetNextWindowCollapsedCond; 413 ImRect SetNextWindowSizeConstraintRect; // Valid if 'SetNextWindowSizeConstraint' is true 414 ImGuiSizeConstraintCallback SetNextWindowSizeConstraintCallback; 415 void* SetNextWindowSizeConstraintCallbackUserData; 416 bool SetNextWindowSizeConstraint; 417 bool SetNextWindowFocus; 418 bool SetNextTreeNodeOpenVal; 419 ImGuiSetCond SetNextTreeNodeOpenCond; 420 421 // Render 422 ImDrawData RenderDrawData; // Main ImDrawData instance to pass render information to the user 423 ImVector<ImDrawList*> RenderDrawLists[3]; 424 float ModalWindowDarkeningRatio; 425 ImDrawList OverlayDrawList; // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays 426 ImGuiMouseCursor MouseCursor; 427 ImGuiMouseCursorData MouseCursorData[ImGuiMouseCursor_Count_]; 428 429 // Widget state 430 ImGuiTextEditState InputTextState; 431 ImFont InputTextPasswordFont; 432 ImGuiID ScalarAsInputTextId; // Temporary text input when CTRL+clicking on a slider, etc. 433 ImGuiStorage ColorEditModeStorage; // Store user selection of color edit mode 434 float DragCurrentValue; // Currently dragged value, always float, not rounded by end-user precision settings 435 ImVec2 DragLastMouseDelta; 436 float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio 437 float DragSpeedScaleSlow; 438 float DragSpeedScaleFast; 439 ImVec2 ScrollbarClickDeltaToGrabCenter; // Distance between mouse and center of grab box, normalized in parent space. Use storage? 440 char Tooltip[1024]; 441 char* PrivateClipboard; // If no custom clipboard handler is defined 442 ImVec2 OsImePosRequest, OsImePosSet; // Cursor position request & last passed to the OS Input Method Editor 443 444 // Logging 445 bool LogEnabled; 446 FILE* LogFile; // If != NULL log to stdout/ file 447 ImGuiTextBuffer* LogClipboard; // Else log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators. 448 int LogStartDepth; 449 int LogAutoExpandMaxDepth; 450 451 // Misc 452 float FramerateSecPerFrame[120]; // calculate estimate of framerate for user 453 int FramerateSecPerFrameIdx; 454 float FramerateSecPerFrameAccum; 455 int CaptureMouseNextFrame; // explicit capture via CaptureInputs() sets those flags 456 int CaptureKeyboardNextFrame; 457 char TempBuffer[1024*3+1]; // temporary text buffer 458 459 ImGuiContext() 460 { 461 Initialized = false; 462 Font = NULL; 463 FontSize = FontBaseSize = 0.0f; 464 FontTexUvWhitePixel = ImVec2(0.0f, 0.0f); 465 466 Time = 0.0f; 467 FrameCount = 0; 468 FrameCountEnded = FrameCountRendered = -1; 469 CurrentWindow = NULL; 470 FocusedWindow = NULL; 471 HoveredWindow = NULL; 472 HoveredRootWindow = NULL; 473 HoveredId = 0; 474 HoveredIdAllowOverlap = false; 475 HoveredIdPreviousFrame = 0; 476 ActiveId = 0; 477 ActiveIdPreviousFrame = 0; 478 ActiveIdIsAlive = false; 479 ActiveIdIsJustActivated = false; 480 ActiveIdAllowOverlap = false; 481 ActiveIdClickOffset = ImVec2(-1,-1); 482 ActiveIdWindow = NULL; 483 MovedWindow = NULL; 484 MovedWindowMoveId = 0; 485 SettingsDirtyTimer = 0.0f; 486 487 SetNextWindowPosVal = ImVec2(0.0f, 0.0f); 488 SetNextWindowSizeVal = ImVec2(0.0f, 0.0f); 489 SetNextWindowCollapsedVal = false; 490 SetNextWindowPosCond = 0; 491 SetNextWindowSizeCond = 0; 492 SetNextWindowContentSizeCond = 0; 493 SetNextWindowCollapsedCond = 0; 494 SetNextWindowSizeConstraintRect = ImRect(); 495 SetNextWindowSizeConstraintCallback = NULL; 496 SetNextWindowSizeConstraintCallbackUserData = NULL; 497 SetNextWindowSizeConstraint = false; 498 SetNextWindowFocus = false; 499 SetNextTreeNodeOpenVal = false; 500 SetNextTreeNodeOpenCond = 0; 501 502 ScalarAsInputTextId = 0; 503 DragCurrentValue = 0.0f; 504 DragLastMouseDelta = ImVec2(0.0f, 0.0f); 505 DragSpeedDefaultRatio = 1.0f / 100.0f; 506 DragSpeedScaleSlow = 0.01f; 507 DragSpeedScaleFast = 10.0f; 508 ScrollbarClickDeltaToGrabCenter = ImVec2(0.0f, 0.0f); 509 memset(Tooltip, 0, sizeof(Tooltip)); 510 PrivateClipboard = NULL; 511 OsImePosRequest = OsImePosSet = ImVec2(-1.0f, -1.0f); 512 513 ModalWindowDarkeningRatio = 0.0f; 514 OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging 515 MouseCursor = ImGuiMouseCursor_Arrow; 516 memset(MouseCursorData, 0, sizeof(MouseCursorData)); 517 518 LogEnabled = false; 519 LogFile = NULL; 520 LogClipboard = NULL; 521 LogStartDepth = 0; 522 LogAutoExpandMaxDepth = 2; 523 524 memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame)); 525 FramerateSecPerFrameIdx = 0; 526 FramerateSecPerFrameAccum = 0.0f; 527 CaptureMouseNextFrame = CaptureKeyboardNextFrame = -1; 528 memset(TempBuffer, 0, sizeof(TempBuffer)); 529 } 530 }; 531 532 // Transient per-window data, reset at the beginning of the frame 533 // FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiDrawContext is quite tenuous and could be reconsidered. 534 struct IMGUI_API ImGuiDrawContext 535 { 536 ImVec2 CursorPos; 537 ImVec2 CursorPosPrevLine; 538 ImVec2 CursorStartPos; 539 ImVec2 CursorMaxPos; // Implicitly calculate the size of our contents, always extending. Saved into window->SizeContents at the end of the frame 540 float CurrentLineHeight; 541 float CurrentLineTextBaseOffset; 542 float PrevLineHeight; 543 float PrevLineTextBaseOffset; 544 float LogLinePosY; 545 int TreeDepth; 546 ImGuiID LastItemId; 547 ImRect LastItemRect; 548 bool LastItemHoveredAndUsable; // Item rectangle is hovered, and its window is currently interactable with (not blocked by a popup preventing access to the window) 549 bool LastItemHoveredRect; // Item rectangle is hovered, but its window may or not be currently interactable with (might be blocked by a popup preventing access to the window) 550 bool MenuBarAppending; 551 float MenuBarOffsetX; 552 ImVector<ImGuiWindow*> ChildWindows; 553 ImGuiStorage* StateStorage; 554 ImGuiLayoutType LayoutType; 555 556 // 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. 557 float ItemWidth; // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window 558 float TextWrapPos; // == TextWrapPosStack.back() [empty == -1.0f] 559 bool AllowKeyboardFocus; // == AllowKeyboardFocusStack.back() [empty == true] 560 bool ButtonRepeat; // == ButtonRepeatStack.back() [empty == false] 561 ImVector<float> ItemWidthStack; 562 ImVector<float> TextWrapPosStack; 563 ImVector<bool> AllowKeyboardFocusStack; 564 ImVector<bool> ButtonRepeatStack; 565 ImVector<ImGuiGroupData>GroupStack; 566 ImGuiColorEditMode ColorEditMode; 567 int StackSizesBackup[6]; // Store size of various stacks for asserting 568 569 float IndentX; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.) 570 float GroupOffsetX; 571 float ColumnsOffsetX; // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API. 572 int ColumnsCurrent; 573 int ColumnsCount; 574 float ColumnsMinX; 575 float ColumnsMaxX; 576 float ColumnsStartPosY; 577 float ColumnsCellMinY; 578 float ColumnsCellMaxY; 579 bool ColumnsShowBorders; 580 ImGuiID ColumnsSetId; 581 ImVector<ImGuiColumnData> ColumnsData; 582 583 ImGuiDrawContext() 584 { 585 CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f); 586 CurrentLineHeight = PrevLineHeight = 0.0f; 587 CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f; 588 LogLinePosY = -1.0f; 589 TreeDepth = 0; 590 LastItemId = 0; 591 LastItemRect = ImRect(0.0f,0.0f,0.0f,0.0f); 592 LastItemHoveredAndUsable = LastItemHoveredRect = false; 593 MenuBarAppending = false; 594 MenuBarOffsetX = 0.0f; 595 StateStorage = NULL; 596 LayoutType = ImGuiLayoutType_Vertical; 597 ItemWidth = 0.0f; 598 ButtonRepeat = false; 599 AllowKeyboardFocus = true; 600 TextWrapPos = -1.0f; 601 ColorEditMode = ImGuiColorEditMode_RGB; 602 memset(StackSizesBackup, 0, sizeof(StackSizesBackup)); 603 604 IndentX = 0.0f; 605 GroupOffsetX = 0.0f; 606 ColumnsOffsetX = 0.0f; 607 ColumnsCurrent = 0; 608 ColumnsCount = 1; 609 ColumnsMinX = ColumnsMaxX = 0.0f; 610 ColumnsStartPosY = 0.0f; 611 ColumnsCellMinY = ColumnsCellMaxY = 0.0f; 612 ColumnsShowBorders = true; 613 ColumnsSetId = 0; 614 } 615 }; 616 617 // Windows data 618 struct IMGUI_API ImGuiWindow 619 { 620 char* Name; 621 ImGuiID ID; // == ImHash(Name) 622 ImGuiWindowFlags Flags; // See enum ImGuiWindowFlags_ 623 int IndexWithinParent; // Order within immediate parent window, if we are a child window. Otherwise 0. 624 ImVec2 PosFloat; 625 ImVec2 Pos; // Position rounded-up to nearest pixel 626 ImVec2 Size; // Current size (==SizeFull or collapsed title bar size) 627 ImVec2 SizeFull; // Size when non collapsed 628 ImVec2 SizeContents; // Size of contents (== extents reach of the drawing cursor) from previous frame 629 ImVec2 SizeContentsExplicit; // Size of contents explicitly set by the user via SetNextWindowContentSize() 630 ImRect ContentsRegionRect; // Maximum visible content position in window coordinates. ~~ (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis 631 ImVec2 WindowPadding; // Window padding at the time of begin. We need to lock it, in particular manipulation of the ShowBorder would have an effect 632 ImGuiID MoveId; // == window->GetID("#MOVE") 633 ImVec2 Scroll; 634 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) 635 ImVec2 ScrollTargetCenterRatio; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered 636 bool ScrollbarX, ScrollbarY; 637 ImVec2 ScrollbarSizes; 638 float BorderSize; 639 bool Active; // Set to true on Begin() 640 bool WasActive; 641 bool Accessed; // Set to true when any widget access the current window 642 bool Collapsed; // Set when collapsing window to become only title-bar 643 bool SkipItems; // == Visible && !Collapsed 644 int BeginCount; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs) 645 ImGuiID PopupId; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling) 646 int AutoFitFramesX, AutoFitFramesY; 647 bool AutoFitOnlyGrows; 648 int AutoPosLastDirection; 649 int HiddenFrames; 650 int SetWindowPosAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowPos() call will succeed with this particular flag. 651 int SetWindowSizeAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowSize() call will succeed with this particular flag. 652 int SetWindowCollapsedAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowCollapsed() call will succeed with this particular flag. 653 bool SetWindowPosCenterWanted; 654 655 ImGuiDrawContext DC; // Temporary per-window data, reset at the beginning of the frame 656 ImVector<ImGuiID> IDStack; // ID stack. ID are hashes seeded with the value at the top of the stack 657 ImRect ClipRect; // = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2. 658 ImRect WindowRectClipped; // = WindowRect just after setup in Begin(). == window->Rect() for root window. 659 int LastFrameActive; 660 float ItemWidthDefault; 661 ImGuiSimpleColumns MenuColumns; // Simplified columns storage for menu items 662 ImGuiStorage StateStorage; 663 float FontWindowScale; // Scale multiplier per-window 664 ImDrawList* DrawList; 665 ImGuiWindow* RootWindow; // If we are a child window, this is pointing to the first non-child parent window. Else point to ourself. 666 ImGuiWindow* RootNonPopupWindow; // If we are a child window, this is pointing to the first non-child non-popup parent window. Else point to ourself. 667 ImGuiWindow* ParentWindow; // If we are a child window, this is pointing to our parent window. Else point to NULL. 668 669 // Navigation / Focus 670 int FocusIdxAllCounter; // Start at -1 and increase as assigned via FocusItemRegister() 671 int FocusIdxTabCounter; // (same, but only count widgets which you can Tab through) 672 int FocusIdxAllRequestCurrent; // Item being requested for focus 673 int FocusIdxTabRequestCurrent; // Tab-able item being requested for focus 674 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) 675 int FocusIdxTabRequestNext; // " 676 677 public: 678 ImGuiWindow(const char* name); 679 ~ImGuiWindow(); 680 681 ImGuiID GetID(const char* str, const char* str_end = NULL); 682 ImGuiID GetID(const void* ptr); 683 ImGuiID GetIDNoKeepAlive(const char* str, const char* str_end = NULL); 684 685 ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x+Size.x, Pos.y+Size.y); } 686 float CalcFontSize() const { return GImGui->FontBaseSize * FontWindowScale; } 687 float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f; } 688 ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); } 689 float MenuBarHeight() const { return (Flags & ImGuiWindowFlags_MenuBar) ? CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f : 0.0f; } 690 ImRect MenuBarRect() const { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); } 691 }; 692 693 //----------------------------------------------------------------------------- 694 // Internal API 695 // No guarantee of forward compatibility here. 696 //----------------------------------------------------------------------------- 697 698 namespace ImGui 699 { 700 // We should always have a CurrentWindow in the stack (there is an implicit "Debug" window) 701 // If this ever crash because g.CurrentWindow is NULL it means that either 702 // - ImGui::NewFrame() has never been called, which is illegal. 703 // - You are calling ImGui functions after ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal. 704 inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; } 705 inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->Accessed = true; return g.CurrentWindow; } 706 IMGUI_API ImGuiWindow* GetParentWindow(); 707 IMGUI_API ImGuiWindow* FindWindowByName(const char* name); 708 IMGUI_API void FocusWindow(ImGuiWindow* window); 709 710 IMGUI_API void EndFrame(); // Ends the ImGui frame. Automatically called by Render()! you most likely don't need to ever call that yourself directly. If you don't need to render you can call EndFrame() but you'll have wasted CPU already. If you don't need to render, don't create any windows instead! 711 712 IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow* window); 713 IMGUI_API void ClearActiveID(); 714 IMGUI_API void SetHoveredID(ImGuiID id); 715 IMGUI_API void KeepAliveID(ImGuiID id); 716 717 IMGUI_API void ItemSize(const ImVec2& size, float text_offset_y = 0.0f); 718 IMGUI_API void ItemSize(const ImRect& bb, float text_offset_y = 0.0f); 719 IMGUI_API bool ItemAdd(const ImRect& bb, const ImGuiID* id); 720 IMGUI_API bool IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged); 721 IMGUI_API bool IsHovered(const ImRect& bb, ImGuiID id, bool flatten_childs = false); 722 IMGUI_API bool FocusableItemRegister(ImGuiWindow* window, bool is_active, bool tab_stop = true); // Return true if focus is requested 723 IMGUI_API void FocusableItemUnregister(ImGuiWindow* window); 724 IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_x, float default_y); 725 IMGUI_API float CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x); 726 727 IMGUI_API void OpenPopupEx(const char* str_id, bool reopen_existing); 728 729 // NB: All position are in absolute pixels coordinates (not window coordinates) 730 // FIXME: All those functions are a mess and needs to be refactored into something decent. AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. 731 // We need: a sort of symbol library, preferably baked into font atlas when possible + decent text rendering helpers. 732 IMGUI_API void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true); 733 IMGUI_API void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width); 734 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); 735 IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f); 736 IMGUI_API void RenderCollapseTriangle(ImVec2 pos, bool is_open, float scale = 1.0f); 737 IMGUI_API void RenderBullet(ImVec2 pos); 738 IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col); 739 IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text. 740 741 IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0); 742 IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0,0), ImGuiButtonFlags flags = 0); 743 IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos, float radius); 744 745 IMGUI_API bool SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, ImGuiSliderFlags flags = 0); 746 IMGUI_API bool SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power); 747 IMGUI_API bool SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* display_format); 748 749 IMGUI_API bool DragBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_speed, float v_min, float v_max, int decimal_precision, float power); 750 IMGUI_API bool DragFloatN(const char* label, float* v, int components, float v_speed, float v_min, float v_max, const char* display_format, float power); 751 IMGUI_API bool DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* display_format); 752 753 IMGUI_API bool InputTextEx(const char* label, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback = NULL, void* user_data = NULL); 754 IMGUI_API bool InputFloatN(const char* label, float* v, int components, int decimal_precision, ImGuiInputTextFlags extra_flags); 755 IMGUI_API bool InputIntN(const char* label, int* v, int components, ImGuiInputTextFlags extra_flags); 756 IMGUI_API bool InputScalarEx(const char* label, ImGuiDataType data_type, void* data_ptr, void* step_ptr, void* step_fast_ptr, const char* scalar_format, ImGuiInputTextFlags extra_flags); 757 IMGUI_API bool InputScalarAsWidgetReplacement(const ImRect& aabb, const char* label, ImGuiDataType data_type, void* data_ptr, ImGuiID id, int decimal_precision); 758 759 IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL); 760 IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0); // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging 761 IMGUI_API void TreePushRawID(ImGuiID id); 762 763 IMGUI_API void PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size); 764 765 IMGUI_API int ParseFormatPrecision(const char* fmt, int default_value); 766 IMGUI_API float RoundScalar(float value, int decimal_precision); 767 768 } // namespace ImGui 769 770 #ifdef __clang__ 771 #pragma clang diagnostic pop 772 #endif 773 774 #ifdef _MSC_VER 775 #pragma warning (pop) 776 #endif