| // dear imgui, v1.53 |
| // (internals) |
| |
| // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility! |
| // Set: |
| // #define IMGUI_DEFINE_MATH_OPERATORS |
| // 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) |
| |
| #pragma once |
| |
| #ifndef IMGUI_VERSION |
| #error Must include imgui.h before imgui_internal.h |
| #endif |
| |
| #include <stdio.h> // FILE* |
| #include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf |
| |
| #ifdef _MSC_VER |
| #pragma warning (push) |
| #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) |
| #endif |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wunused-function" // for stb_textedit.h |
| #pragma clang diagnostic ignored "-Wmissing-prototypes" // for stb_textedit.h |
| #pragma clang diagnostic ignored "-Wold-style-cast" |
| #endif |
| |
| //----------------------------------------------------------------------------- |
| // Forward Declarations |
| //----------------------------------------------------------------------------- |
| |
| struct ImRect; |
| struct ImGuiColMod; |
| struct ImGuiStyleMod; |
| struct ImGuiGroupData; |
| struct ImGuiSimpleColumns; |
| struct ImGuiDrawContext; |
| struct ImGuiTextEditState; |
| struct ImGuiMouseCursorData; |
| struct ImGuiPopupRef; |
| struct ImGuiWindow; |
| struct ImGuiWindowSettings; |
| |
| typedef int ImGuiLayoutType; // enum: horizontal or vertical // enum ImGuiLayoutType_ |
| typedef int ImGuiButtonFlags; // flags: for ButtonEx(), ButtonBehavior() // enum ImGuiButtonFlags_ |
| typedef int ImGuiItemFlags; // flags: for PushItemFlag() // enum ImGuiItemFlags_ |
| typedef int ImGuiSeparatorFlags; // flags: for Separator() - internal // enum ImGuiSeparatorFlags_ |
| typedef int ImGuiSliderFlags; // flags: for SliderBehavior() // enum ImGuiSliderFlags_ |
| |
| //------------------------------------------------------------------------- |
| // STB libraries |
| //------------------------------------------------------------------------- |
| |
| namespace ImGuiStb |
| { |
| |
| #undef STB_TEXTEDIT_STRING |
| #undef STB_TEXTEDIT_CHARTYPE |
| #define STB_TEXTEDIT_STRING ImGuiTextEditState |
| #define STB_TEXTEDIT_CHARTYPE ImWchar |
| #define STB_TEXTEDIT_GETWIDTH_NEWLINE -1.0f |
| #include "stb_textedit.h" |
| |
| } // namespace ImGuiStb |
| |
| //----------------------------------------------------------------------------- |
| // Context |
| //----------------------------------------------------------------------------- |
| |
| #ifndef GImGui |
| extern IMGUI_API ImGuiContext* GImGui; // Current implicit ImGui context pointer |
| #endif |
| |
| //----------------------------------------------------------------------------- |
| // Helpers |
| //----------------------------------------------------------------------------- |
| |
| #define IM_PI 3.14159265358979323846f |
| #define IM_OFFSETOF(_TYPE,_ELM) ((size_t)&(((_TYPE*)0)->_ELM)) |
| |
| // Helpers: UTF-8 <> wchar |
| IMGUI_API int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count |
| IMGUI_API int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // return input UTF-8 bytes count |
| 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 |
| IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count) |
| 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 |
| |
| // Helpers: Misc |
| IMGUI_API ImU32 ImHash(const void* data, int data_size, ImU32 seed = 0); // Pass data_size==0 for zero-terminated strings |
| IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* file_open_mode, int* out_file_size = NULL, int padding_bytes = 0); |
| IMGUI_API FILE* ImFileOpen(const char* filename, const char* file_open_mode); |
| static inline bool ImCharIsSpace(int c) { return c == ' ' || c == '\t' || c == 0x3000; } |
| static inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; } |
| 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; } |
| |
| // Helpers: Geometry |
| IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p); |
| IMGUI_API bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p); |
| IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p); |
| 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); |
| |
| // Helpers: String |
| IMGUI_API int ImStricmp(const char* str1, const char* str2); |
| IMGUI_API int ImStrnicmp(const char* str1, const char* str2, size_t count); |
| IMGUI_API void ImStrncpy(char* dst, const char* src, size_t count); |
| IMGUI_API char* ImStrdup(const char* str); |
| IMGUI_API char* ImStrchrRange(const char* str_begin, const char* str_end, char c); |
| IMGUI_API int ImStrlenW(const ImWchar* str); |
| IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line |
| IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end); |
| IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3); |
| IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3); |
| |
| // Helpers: Math |
| // 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) |
| #ifdef IMGUI_DEFINE_MATH_OPERATORS |
| static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x*rhs, lhs.y*rhs); } |
| static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x/rhs, lhs.y/rhs); } |
| static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x+rhs.x, lhs.y+rhs.y); } |
| static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x-rhs.x, lhs.y-rhs.y); } |
| static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x*rhs.x, lhs.y*rhs.y); } |
| static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x/rhs.x, lhs.y/rhs.y); } |
| static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs) { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; } |
| static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs) { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; } |
| static inline ImVec2& operator*=(ImVec2& lhs, const float rhs) { lhs.x *= rhs; lhs.y *= rhs; return lhs; } |
| static inline ImVec2& operator/=(ImVec2& lhs, const float rhs) { lhs.x /= rhs; lhs.y /= rhs; return lhs; } |
| 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); } |
| 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); } |
| 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); } |
| #endif |
| |
| static inline int ImMin(int lhs, int rhs) { return lhs < rhs ? lhs : rhs; } |
| static inline int ImMax(int lhs, int rhs) { return lhs >= rhs ? lhs : rhs; } |
| static inline float ImMin(float lhs, float rhs) { return lhs < rhs ? lhs : rhs; } |
| static inline float ImMax(float lhs, float rhs) { return lhs >= rhs ? lhs : rhs; } |
| static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(ImMin(lhs.x,rhs.x), ImMin(lhs.y,rhs.y)); } |
| static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(ImMax(lhs.x,rhs.x), ImMax(lhs.y,rhs.y)); } |
| static inline int ImClamp(int v, int mn, int mx) { return (v < mn) ? mn : (v > mx) ? mx : v; } |
| static inline float ImClamp(float v, float mn, float mx) { return (v < mn) ? mn : (v > mx) ? mx : v; } |
| 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)); } |
| static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; } |
| static inline void ImSwap(int& a, int& b) { int tmp = a; a = b; b = tmp; } |
| static inline void ImSwap(float& a, float& b) { float tmp = a; a = b; b = tmp; } |
| static inline int ImLerp(int a, int b, float t) { return (int)(a + (b - a) * t); } |
| static inline float ImLerp(float a, float b, float t) { return a + (b - a) * t; } |
| 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); } |
| 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); } |
| 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); } |
| static inline float ImLengthSqr(const ImVec2& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y; } |
| static inline float ImLengthSqr(const ImVec4& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y + lhs.z*lhs.z + lhs.w*lhs.w; } |
| 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; } |
| static inline float ImFloor(float f) { return (float)(int)f; } |
| static inline ImVec2 ImFloor(const ImVec2& v) { return ImVec2((float)(int)v.x, (float)(int)v.y); } |
| static inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; } |
| 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); } |
| 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; } |
| static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); } |
| |
| // We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax. |
| // 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. |
| struct ImNewPlacementDummy {}; |
| inline void* operator new(size_t, ImNewPlacementDummy, void* ptr) { return ptr; } |
| inline void operator delete(void*, ImNewPlacementDummy, void*) {} // This is only required so we can use the symetrical new() |
| #define IM_PLACEMENT_NEW(_PTR) new(ImNewPlacementDummy(), _PTR) |
| #define IM_NEW(_TYPE) new(ImNewPlacementDummy(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE |
| template <typename T> void IM_DELETE(T*& p) { if (p) { p->~T(); ImGui::MemFree(p); p = NULL; } } |
| |
| //----------------------------------------------------------------------------- |
| // Types |
| //----------------------------------------------------------------------------- |
| |
| // Internal Drag and Drop payload types. String starting with '_' are reserved for Dear ImGui. |
| #define IMGUI_PAYLOAD_TYPE_DOCKABLE "_IMDOCK" // ImGuiWindow* // [Internal] Docking/tabs |
| |
| enum ImGuiButtonFlags_ |
| { |
| ImGuiButtonFlags_Repeat = 1 << 0, // hold to repeat |
| ImGuiButtonFlags_PressedOnClickRelease = 1 << 1, // return true on click + release on same item [DEFAULT if no PressedOn* flag is set] |
| ImGuiButtonFlags_PressedOnClick = 1 << 2, // return true on click (default requires click+release) |
| ImGuiButtonFlags_PressedOnRelease = 1 << 3, // return true on release (default requires click+release) |
| ImGuiButtonFlags_PressedOnDoubleClick = 1 << 4, // return true on double-click (default requires click+release) |
| ImGuiButtonFlags_FlattenChildren = 1 << 5, // allow interactions even if a child window is overlapping |
| ImGuiButtonFlags_AllowItemOverlap = 1 << 6, // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap() |
| ImGuiButtonFlags_DontClosePopups = 1 << 7, // disable automatically closing parent popup on press // [UNUSED] |
| ImGuiButtonFlags_Disabled = 1 << 8, // disable interactions |
| 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 |
| ImGuiButtonFlags_NoKeyModifiers = 1 << 10, // disable interaction if a key modifier is held |
| ImGuiButtonFlags_NoHoldingActiveID = 1 << 11, // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only) |
| ImGuiButtonFlags_PressedOnDragDropHold = 1 << 12 // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers) |
| }; |
| |
| enum ImGuiSliderFlags_ |
| { |
| ImGuiSliderFlags_Vertical = 1 << 0 |
| }; |
| |
| enum ImGuiColumnsFlags_ |
| { |
| // Default: 0 |
| ImGuiColumnsFlags_NoBorder = 1 << 0, // Disable column dividers |
| ImGuiColumnsFlags_NoResize = 1 << 1, // Disable resizing columns when clicking on the dividers |
| ImGuiColumnsFlags_NoPreserveWidths = 1 << 2, // Disable column width preservation when adjusting columns |
| ImGuiColumnsFlags_NoForceWithinWindow = 1 << 3, // Disable forcing columns to fit within window |
| 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. |
| }; |
| |
| enum ImGuiSelectableFlagsPrivate_ |
| { |
| // NB: need to be in sync with last value of ImGuiSelectableFlags_ |
| ImGuiSelectableFlags_Menu = 1 << 3, // -> PressedOnClick |
| ImGuiSelectableFlags_MenuItem = 1 << 4, // -> PressedOnRelease |
| ImGuiSelectableFlags_Disabled = 1 << 5, |
| ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 6 |
| }; |
| |
| enum ImGuiSeparatorFlags_ |
| { |
| ImGuiSeparatorFlags_Horizontal = 1 << 0, // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar |
| ImGuiSeparatorFlags_Vertical = 1 << 1 |
| }; |
| |
| // FIXME: this is in development, not exposed/functional as a generic feature yet. |
| enum ImGuiLayoutType_ |
| { |
| ImGuiLayoutType_Vertical, |
| ImGuiLayoutType_Horizontal |
| }; |
| |
| enum ImGuiAxis |
| { |
| ImGuiAxis_None = -1, |
| ImGuiAxis_X = 0, |
| ImGuiAxis_Y = 1 |
| }; |
| |
| enum ImGuiPlotType |
| { |
| ImGuiPlotType_Lines, |
| ImGuiPlotType_Histogram |
| }; |
| |
| enum ImGuiDataType |
| { |
| ImGuiDataType_Int, |
| ImGuiDataType_Float, |
| ImGuiDataType_Float2 |
| }; |
| |
| enum ImGuiDir |
| { |
| ImGuiDir_None = -1, |
| ImGuiDir_Left = 0, |
| ImGuiDir_Right = 1, |
| ImGuiDir_Up = 2, |
| ImGuiDir_Down = 3, |
| ImGuiDir_Count_ |
| }; |
| |
| // 2D axis aligned bounding-box |
| // NB: we can't rely on ImVec2 math operators being available here |
| struct IMGUI_API ImRect |
| { |
| ImVec2 Min; // Upper-left |
| ImVec2 Max; // Lower-right |
| |
| ImRect() : Min(FLT_MAX,FLT_MAX), Max(-FLT_MAX,-FLT_MAX) {} |
| ImRect(const ImVec2& min, const ImVec2& max) : Min(min), Max(max) {} |
| ImRect(const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {} |
| ImRect(float x1, float y1, float x2, float y2) : Min(x1, y1), Max(x2, y2) {} |
| |
| ImVec2 GetCenter() const { return ImVec2((Min.x+Max.x)*0.5f, (Min.y+Max.y)*0.5f); } |
| ImVec2 GetSize() const { return ImVec2(Max.x-Min.x, Max.y-Min.y); } |
| float GetWidth() const { return Max.x-Min.x; } |
| float GetHeight() const { return Max.y-Min.y; } |
| ImVec2 GetTL() const { return Min; } // Top-left |
| ImVec2 GetTR() const { return ImVec2(Max.x, Min.y); } // Top-right |
| ImVec2 GetBL() const { return ImVec2(Min.x, Max.y); } // Bottom-left |
| ImVec2 GetBR() const { return Max; } // Bottom-right |
| bool Contains(const ImVec2& p) const { return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; } |
| 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; } |
| 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; } |
| 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; } |
| 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; } |
| void Expand(const float amount) { Min.x -= amount; Min.y -= amount; Max.x += amount; Max.y += amount; } |
| void Expand(const ImVec2& amount) { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; } |
| void Translate(const ImVec2& v) { Min.x += v.x; Min.y += v.y; Max.x += v.x; Max.y += v.y; } |
| void ClipWith(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; } |
| 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; } |
| void FixInverted() { if (Min.x > Max.x) ImSwap(Min.x, Max.x); if (Min.y > Max.y) ImSwap(Min.y, Max.y); } |
| bool IsFinite() const { return Min.x != FLT_MAX; } |
| ImVec2 GetClosestPoint(ImVec2 p, bool on_edge) const |
| { |
| if (!on_edge && Contains(p)) |
| return p; |
| if (p.x > Max.x) p.x = Max.x; |
| else if (p.x < Min.x) p.x = Min.x; |
| if (p.y > Max.y) p.y = Max.y; |
| else if (p.y < Min.y) p.y = Min.y; |
| return p; |
| } |
| }; |
| |
| // Stacked color modifier, backup of modified data so we can restore it |
| struct ImGuiColMod |
| { |
| ImGuiCol Col; |
| ImVec4 BackupValue; |
| }; |
| |
| // Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable. |
| struct ImGuiStyleMod |
| { |
| ImGuiStyleVar VarIdx; |
| union { int BackupInt[2]; float BackupFloat[2]; }; |
| ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; } |
| ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; } |
| ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; } |
| }; |
| |
| // Stacked data for BeginGroup()/EndGroup() |
| struct ImGuiGroupData |
| { |
| ImVec2 BackupCursorPos; |
| ImVec2 BackupCursorMaxPos; |
| float BackupIndentX; |
| float BackupGroupOffsetX; |
| float BackupCurrentLineHeight; |
| float BackupCurrentLineTextBaseOffset; |
| float BackupLogLinePosY; |
| bool BackupActiveIdIsAlive; |
| bool AdvanceCursor; |
| }; |
| |
| // Simple column measurement currently used for MenuItem() only. This is very short-sighted/throw-away code and NOT a generic helper. |
| struct IMGUI_API ImGuiSimpleColumns |
| { |
| int Count; |
| float Spacing; |
| float Width, NextWidth; |
| float Pos[8], NextWidths[8]; |
| |
| ImGuiSimpleColumns(); |
| void Update(int count, float spacing, bool clear); |
| float DeclColumns(float w0, float w1, float w2); |
| float CalcExtraSpace(float avail_w); |
| }; |
| |
| // Internal state of the currently focused/edited text input box |
| struct IMGUI_API ImGuiTextEditState |
| { |
| ImGuiID Id; // widget id owning the text state |
| 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. |
| ImVector<char> InitialText; // backup of end-user buffer at the time of focus (in UTF-8, unaltered) |
| ImVector<char> TempTextBuffer; |
| int CurLenA, CurLenW; // we need to maintain our buffer length in both UTF-8 and wchar format. |
| int BufSizeA; // end-user buffer size |
| float ScrollX; |
| ImGuiStb::STB_TexteditState StbState; |
| float CursorAnim; |
| bool CursorFollow; |
| bool SelectedAllMouseLock; |
| |
| ImGuiTextEditState() { memset(this, 0, sizeof(*this)); } |
| void CursorAnimReset() { CursorAnim = -0.30f; } // After a user-input the cursor stays on for a while without blinking |
| void CursorClamp() { StbState.cursor = ImMin(StbState.cursor, CurLenW); StbState.select_start = ImMin(StbState.select_start, CurLenW); StbState.select_end = ImMin(StbState.select_end, CurLenW); } |
| bool HasSelection() const { return StbState.select_start != StbState.select_end; } |
| void ClearSelection() { StbState.select_start = StbState.select_end = StbState.cursor; } |
| void SelectAll() { StbState.select_start = 0; StbState.select_end = CurLenW; StbState.cursor = StbState.select_end; StbState.has_preferred_x = false; } |
| void OnKeyPressed(int key); |
| }; |
| |
| // Data saved in imgui.ini file |
| struct ImGuiWindowSettings |
| { |
| char* Name; |
| ImGuiID Id; |
| ImVec2 Pos; |
| ImVec2 Size; |
| bool Collapsed; |
| |
| ImGuiWindowSettings() { Name = NULL; Id = 0; Pos = Size = ImVec2(0,0); Collapsed = false; } |
| }; |
| |
| struct ImGuiSettingsHandler |
| { |
| const char* TypeName; // Short description stored in .ini file. Disallowed characters: '[' ']' |
| ImGuiID TypeHash; // == ImHash(TypeName, 0, 0) |
| void* (*ReadOpenFn)(ImGuiContext& ctx, const char* name); |
| void (*ReadLineFn)(ImGuiContext& ctx, void* entry, const char* line); |
| void (*WriteAllFn)(ImGuiContext& ctx, ImGuiTextBuffer* out_buf); |
| }; |
| |
| // Mouse cursor data (used when io.MouseDrawCursor is set) |
| struct ImGuiMouseCursorData |
| { |
| ImGuiMouseCursor Type; |
| ImVec2 HotOffset; |
| ImVec2 Size; |
| ImVec2 TexUvMin[2]; |
| ImVec2 TexUvMax[2]; |
| }; |
| |
| // Storage for current popup stack |
| struct ImGuiPopupRef |
| { |
| ImGuiID PopupId; // Set on OpenPopup() |
| ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup() |
| ImGuiWindow* ParentWindow; // Set on OpenPopup() |
| ImGuiID ParentMenuSet; // Set on OpenPopup() |
| ImVec2 MousePosOnOpen; // Copy of mouse position at the time of opening popup |
| |
| 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; } |
| }; |
| |
| struct ImGuiColumnData |
| { |
| float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right) |
| float OffsetNormBeforeResize; |
| ImGuiColumnsFlags Flags; // Not exposed |
| ImRect ClipRect; |
| |
| ImGuiColumnData() { OffsetNorm = OffsetNormBeforeResize = 0.0f; Flags = 0; } |
| }; |
| |
| struct ImGuiColumnsSet |
| { |
| ImGuiID ID; |
| ImGuiColumnsFlags Flags; |
| bool IsFirstFrame; |
| bool IsBeingResized; |
| int Current; |
| int Count; |
| float MinX, MaxX; |
| float StartPosY; |
| float StartMaxPosX; // Backup of CursorMaxPos |
| float CellMinY, CellMaxY; |
| ImVector<ImGuiColumnData> Columns; |
| |
| ImGuiColumnsSet() { Clear(); } |
| void Clear() |
| { |
| ID = 0; |
| Flags = 0; |
| IsFirstFrame = false; |
| IsBeingResized = false; |
| Current = 0; |
| Count = 1; |
| MinX = MaxX = 0.0f; |
| StartPosY = 0.0f; |
| StartMaxPosX = 0.0f; |
| CellMinY = CellMaxY = 0.0f; |
| Columns.clear(); |
| } |
| }; |
| |
| struct ImDrawListSharedData |
| { |
| ImVec2 TexUvWhitePixel; // UV of white pixel in the atlas |
| ImFont* Font; // Current/default font (optional, for simplified AddText overload) |
| float FontSize; // Current/default font size (optional, for simplified AddText overload) |
| float CurveTessellationTol; |
| ImVec4 ClipRectFullscreen; // Value for PushClipRectFullscreen() |
| |
| // Const data |
| // FIXME: Bake rounded corners fill/borders in atlas |
| ImVec2 CircleVtx12[12]; |
| |
| ImDrawListSharedData(); |
| }; |
| |
| // Main state for ImGui |
| struct ImGuiContext |
| { |
| bool Initialized; |
| ImGuiIO IO; |
| ImGuiStyle Style; |
| ImFont* Font; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back() |
| float FontSize; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window. |
| float FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height. |
| ImDrawListSharedData DrawListSharedData; |
| |
| float Time; |
| int FrameCount; |
| int FrameCountEnded; |
| int FrameCountRendered; |
| ImVector<ImGuiWindow*> Windows; |
| ImVector<ImGuiWindow*> WindowsSortBuffer; |
| ImVector<ImGuiWindow*> CurrentWindowStack; |
| ImGuiStorage WindowsById; |
| int WindowsActiveCount; |
| ImGuiWindow* CurrentWindow; // Being drawn into |
| ImGuiWindow* NavWindow; // Nav/focused window for navigation |
| ImGuiWindow* HoveredWindow; // Will catch mouse inputs |
| ImGuiWindow* HoveredRootWindow; // Will catch mouse inputs (for focus/move only) |
| ImGuiID HoveredId; // Hovered widget |
| bool HoveredIdAllowOverlap; |
| ImGuiID HoveredIdPreviousFrame; |
| float HoveredIdTimer; |
| ImGuiID ActiveId; // Active widget |
| ImGuiID ActiveIdPreviousFrame; |
| float ActiveIdTimer; |
| bool ActiveIdIsAlive; // Active widget has been seen this frame |
| bool ActiveIdIsJustActivated; // Set at the time of activation for one frame |
| bool ActiveIdAllowOverlap; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always) |
| ImVec2 ActiveIdClickOffset; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior) |
| ImGuiWindow* ActiveIdWindow; |
| ImGuiWindow* MovingWindow; // Track the child window we clicked on to move a window. |
| ImGuiID MovingWindowMoveId; // == MovingWindow->MoveId |
| ImVector<ImGuiColMod> ColorModifiers; // Stack for PushStyleColor()/PopStyleColor() |
| ImVector<ImGuiStyleMod> StyleModifiers; // Stack for PushStyleVar()/PopStyleVar() |
| ImVector<ImFont*> FontStack; // Stack for PushFont()/PopFont() |
| ImVector<ImGuiPopupRef> OpenPopupStack; // Which popups are open (persistent) |
| ImVector<ImGuiPopupRef> CurrentPopupStack; // Which level of BeginPopup() we are in (reset every frame) |
| |
| // Storage for SetNexWindow** and SetNextTreeNode*** functions |
| ImVec2 SetNextWindowPosVal; |
| ImVec2 SetNextWindowPosPivot; |
| ImVec2 SetNextWindowSizeVal; |
| ImVec2 SetNextWindowContentSizeVal; |
| bool SetNextWindowCollapsedVal; |
| ImGuiCond SetNextWindowPosCond; |
| ImGuiCond SetNextWindowSizeCond; |
| ImGuiCond SetNextWindowContentSizeCond; |
| ImGuiCond SetNextWindowCollapsedCond; |
| ImRect SetNextWindowSizeConstraintRect; // Valid if 'SetNextWindowSizeConstraint' is true |
| ImGuiSizeConstraintCallback SetNextWindowSizeConstraintCallback; |
| void* SetNextWindowSizeConstraintCallbackUserData; |
| bool SetNextWindowSizeConstraint; |
| bool SetNextWindowFocus; |
| bool SetNextTreeNodeOpenVal; |
| ImGuiCond SetNextTreeNodeOpenCond; |
| |
| // Render |
| ImDrawData RenderDrawData; // Main ImDrawData instance to pass render information to the user |
| ImVector<ImDrawList*> RenderDrawLists[3]; |
| float ModalWindowDarkeningRatio; |
| ImDrawList OverlayDrawList; // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays |
| ImGuiMouseCursor MouseCursor; |
| ImGuiMouseCursorData MouseCursorData[ImGuiMouseCursor_Count_]; |
| |
| // Drag and Drop |
| bool DragDropActive; |
| ImGuiDragDropFlags DragDropSourceFlags; |
| int DragDropMouseButton; |
| ImGuiPayload DragDropPayload; |
| ImRect DragDropTargetRect; |
| ImGuiID DragDropTargetId; |
| float DragDropAcceptIdCurrRectSurface; |
| ImGuiID DragDropAcceptIdCurr; // Target item id (set at the time of accepting the payload) |
| ImGuiID DragDropAcceptIdPrev; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets) |
| int DragDropAcceptFrameCount; // Last time a target expressed a desire to accept the source |
| ImVector<unsigned char> DragDropPayloadBufHeap; // We don't expose the ImVector<> directly |
| unsigned char DragDropPayloadBufLocal[8]; |
| |
| // Widget state |
| ImGuiTextEditState InputTextState; |
| ImFont InputTextPasswordFont; |
| ImGuiID ScalarAsInputTextId; // Temporary text input when CTRL+clicking on a slider, etc. |
| ImGuiColorEditFlags ColorEditOptions; // Store user options for color edit widgets |
| ImVec4 ColorPickerRef; |
| float DragCurrentValue; // Currently dragged value, always float, not rounded by end-user precision settings |
| ImVec2 DragLastMouseDelta; |
| float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio |
| float DragSpeedScaleSlow; |
| float DragSpeedScaleFast; |
| ImVec2 ScrollbarClickDeltaToGrabCenter; // Distance between mouse and center of grab box, normalized in parent space. Use storage? |
| int TooltipOverrideCount; |
| ImVector<char> PrivateClipboard; // If no custom clipboard handler is defined |
| ImVec2 OsImePosRequest, OsImePosSet; // Cursor position request & last passed to the OS Input Method Editor |
| |
| // Settings |
| float SettingsDirtyTimer; // Save .ini Settings on disk when time reaches zero |
| ImVector<ImGuiWindowSettings> SettingsWindows; // .ini settings for ImGuiWindow |
| ImVector<ImGuiSettingsHandler> SettingsHandlers; // List of .ini settings handlers |
| |
| // Logging |
| bool LogEnabled; |
| FILE* LogFile; // If != NULL log to stdout/ file |
| ImGuiTextBuffer* LogClipboard; // Else log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators. |
| int LogStartDepth; |
| int LogAutoExpandMaxDepth; |
| |
| // Misc |
| float FramerateSecPerFrame[120]; // calculate estimate of framerate for user |
| int FramerateSecPerFrameIdx; |
| float FramerateSecPerFrameAccum; |
| int WantCaptureMouseNextFrame; // explicit capture via CaptureInputs() sets those flags |
| int WantCaptureKeyboardNextFrame; |
| int WantTextInputNextFrame; |
| char TempBuffer[1024*3+1]; // temporary text buffer |
| |
| ImGuiContext() : OverlayDrawList(NULL) |
| { |
| Initialized = false; |
| Font = NULL; |
| FontSize = FontBaseSize = 0.0f; |
| |
| Time = 0.0f; |
| FrameCount = 0; |
| FrameCountEnded = FrameCountRendered = -1; |
| WindowsActiveCount = 0; |
| CurrentWindow = NULL; |
| NavWindow = NULL; |
| HoveredWindow = NULL; |
| HoveredRootWindow = NULL; |
| HoveredId = 0; |
| HoveredIdAllowOverlap = false; |
| HoveredIdPreviousFrame = 0; |
| HoveredIdTimer = 0.0f; |
| ActiveId = 0; |
| ActiveIdPreviousFrame = 0; |
| ActiveIdTimer = 0.0f; |
| ActiveIdIsAlive = false; |
| ActiveIdIsJustActivated = false; |
| ActiveIdAllowOverlap = false; |
| ActiveIdClickOffset = ImVec2(-1,-1); |
| ActiveIdWindow = NULL; |
| MovingWindow = NULL; |
| MovingWindowMoveId = 0; |
| |
| SetNextWindowPosVal = ImVec2(0.0f, 0.0f); |
| SetNextWindowSizeVal = ImVec2(0.0f, 0.0f); |
| SetNextWindowCollapsedVal = false; |
| SetNextWindowPosCond = 0; |
| SetNextWindowSizeCond = 0; |
| SetNextWindowContentSizeCond = 0; |
| SetNextWindowCollapsedCond = 0; |
| SetNextWindowSizeConstraintRect = ImRect(); |
| SetNextWindowSizeConstraintCallback = NULL; |
| SetNextWindowSizeConstraintCallbackUserData = NULL; |
| SetNextWindowSizeConstraint = false; |
| SetNextWindowFocus = false; |
| SetNextTreeNodeOpenVal = false; |
| SetNextTreeNodeOpenCond = 0; |
| |
| DragDropActive = false; |
| DragDropSourceFlags = 0; |
| DragDropMouseButton = -1; |
| DragDropTargetId = 0; |
| DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0; |
| DragDropAcceptFrameCount = -1; |
| memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal)); |
| |
| ScalarAsInputTextId = 0; |
| ColorEditOptions = ImGuiColorEditFlags__OptionsDefault; |
| DragCurrentValue = 0.0f; |
| DragLastMouseDelta = ImVec2(0.0f, 0.0f); |
| DragSpeedDefaultRatio = 1.0f / 100.0f; |
| DragSpeedScaleSlow = 1.0f / 100.0f; |
| DragSpeedScaleFast = 10.0f; |
| ScrollbarClickDeltaToGrabCenter = ImVec2(0.0f, 0.0f); |
| TooltipOverrideCount = 0; |
| OsImePosRequest = OsImePosSet = ImVec2(-1.0f, -1.0f); |
| |
| ModalWindowDarkeningRatio = 0.0f; |
| OverlayDrawList._Data = &DrawListSharedData; |
| OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging |
| MouseCursor = ImGuiMouseCursor_Arrow; |
| memset(MouseCursorData, 0, sizeof(MouseCursorData)); |
| |
| SettingsDirtyTimer = 0.0f; |
| |
| LogEnabled = false; |
| LogFile = NULL; |
| LogClipboard = NULL; |
| LogStartDepth = 0; |
| LogAutoExpandMaxDepth = 2; |
| |
| memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame)); |
| FramerateSecPerFrameIdx = 0; |
| FramerateSecPerFrameAccum = 0.0f; |
| WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1; |
| memset(TempBuffer, 0, sizeof(TempBuffer)); |
| } |
| }; |
| |
| // Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin(). |
| enum ImGuiItemFlags_ |
| { |
| ImGuiItemFlags_AllowKeyboardFocus = 1 << 0, // true |
| ImGuiItemFlags_ButtonRepeat = 1 << 1, // false // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings. |
| ImGuiItemFlags_Disabled = 1 << 2, // false // FIXME-WIP: Disable interactions but doesn't affect visuals. Should be: grey out and disable interactions with widgets that affect data + view widgets (WIP) |
| //ImGuiItemFlags_NoNav = 1 << 3, // false |
| //ImGuiItemFlags_NoNavDefaultFocus = 1 << 4, // false |
| ImGuiItemFlags_SelectableDontClosePopup = 1 << 5, // false // MenuItem/Selectable() automatically closes current Popup window |
| ImGuiItemFlags_Default_ = ImGuiItemFlags_AllowKeyboardFocus |
| }; |
| |
| // Transient per-window data, reset at the beginning of the frame |
| // FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiDrawContext is quite tenuous and could be reconsidered. |
| struct IMGUI_API ImGuiDrawContext |
| { |
| ImVec2 CursorPos; |
| ImVec2 CursorPosPrevLine; |
| ImVec2 CursorStartPos; |
| 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 |
| float CurrentLineHeight; |
| float CurrentLineTextBaseOffset; |
| float PrevLineHeight; |
| float PrevLineTextBaseOffset; |
| float LogLinePosY; |
| int TreeDepth; |
| ImGuiID LastItemId; |
| ImRect LastItemRect; |
| bool LastItemRectHoveredRect; |
| bool MenuBarAppending; |
| float MenuBarOffsetX; |
| ImVector<ImGuiWindow*> ChildWindows; |
| ImGuiStorage* StateStorage; |
| ImGuiLayoutType LayoutType; |
| |
| // 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. |
| ImGuiItemFlags ItemFlags; // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default] |
| float ItemWidth; // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window |
| float TextWrapPos; // == TextWrapPosStack.back() [empty == -1.0f] |
| ImVector<ImGuiItemFlags>ItemFlagsStack; |
| ImVector<float> ItemWidthStack; |
| ImVector<float> TextWrapPosStack; |
| ImVector<ImGuiGroupData>GroupStack; |
| int StackSizesBackup[6]; // Store size of various stacks for asserting |
| |
| float IndentX; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.) |
| float GroupOffsetX; |
| 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. |
| ImGuiColumnsSet* ColumnsSet; // Current columns set |
| |
| ImGuiDrawContext() |
| { |
| CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f); |
| CurrentLineHeight = PrevLineHeight = 0.0f; |
| CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f; |
| LogLinePosY = -1.0f; |
| TreeDepth = 0; |
| LastItemId = 0; |
| LastItemRect = ImRect(); |
| LastItemRectHoveredRect = false; |
| MenuBarAppending = false; |
| MenuBarOffsetX = 0.0f; |
| StateStorage = NULL; |
| LayoutType = ImGuiLayoutType_Vertical; |
| ItemWidth = 0.0f; |
| ItemFlags = ImGuiItemFlags_Default_; |
| TextWrapPos = -1.0f; |
| memset(StackSizesBackup, 0, sizeof(StackSizesBackup)); |
| |
| IndentX = 0.0f; |
| GroupOffsetX = 0.0f; |
| ColumnsOffsetX = 0.0f; |
| ColumnsSet = NULL; |
| } |
| }; |
| |
| // Windows data |
| struct IMGUI_API ImGuiWindow |
| { |
| char* Name; |
| ImGuiID ID; // == ImHash(Name) |
| ImGuiWindowFlags Flags; // See enum ImGuiWindowFlags_ |
| ImVec2 PosFloat; |
| ImVec2 Pos; // Position rounded-up to nearest pixel |
| ImVec2 Size; // Current size (==SizeFull or collapsed title bar size) |
| ImVec2 SizeFull; // Size when non collapsed |
| 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. |
| ImVec2 SizeContents; // Size of contents (== extents reach of the drawing cursor) from previous frame. Include decoration, window title, border, menu, etc. |
| ImVec2 SizeContentsExplicit; // Size of contents explicitly set by the user via SetNextWindowContentSize() |
| ImRect ContentsRegionRect; // Maximum visible content position in window coordinates. ~~ (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis |
| ImVec2 WindowPadding; // Window padding at the time of begin. |
| float WindowRounding; // Window rounding at the time of begin. |
| float WindowBorderSize; // Window border size at the time of begin. |
| ImGuiID MoveId; // == window->GetID("#MOVE") |
| ImVec2 Scroll; |
| 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) |
| ImVec2 ScrollTargetCenterRatio; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered |
| bool ScrollbarX, ScrollbarY; |
| ImVec2 ScrollbarSizes; |
| bool Active; // Set to true on Begin() |
| bool WasActive; |
| bool WriteAccessed; // Set to true when any widget access the current window |
| bool Collapsed; // Set when collapsing window to become only title-bar |
| bool SkipItems; // Set when items can safely be all clipped (e.g. window not visible or collapsed) |
| bool Appearing; // Set during the frame where the window is appearing (or re-appearing) |
| bool CloseButton; // Set when the window has a close button (p_open != NULL) |
| int BeginOrderWithinParent; // Order within immediate parent window, if we are a child window. Otherwise 0. |
| int BeginOrderWithinContext; // Order within entire imgui context. This is mostly used for debugging submission order related issues. |
| int BeginCount; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs) |
| ImGuiID PopupId; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling) |
| int AutoFitFramesX, AutoFitFramesY; |
| bool AutoFitOnlyGrows; |
| int AutoFitChildAxises; |
| ImGuiDir AutoPosLastDirection; |
| int HiddenFrames; |
| ImGuiCond SetWindowPosAllowFlags; // store condition flags for next SetWindowPos() call. |
| ImGuiCond SetWindowSizeAllowFlags; // store condition flags for next SetWindowSize() call. |
| ImGuiCond SetWindowCollapsedAllowFlags; // store condition flags for next SetWindowCollapsed() call. |
| ImVec2 SetWindowPosVal; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size) |
| 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. |
| |
| ImGuiDrawContext DC; // Temporary per-window data, reset at the beginning of the frame |
| ImVector<ImGuiID> IDStack; // ID stack. ID are hashes seeded with the value at the top of the stack |
| ImRect ClipRect; // = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2. |
| ImRect WindowRectClipped; // = WindowRect just after setup in Begin(). == window->Rect() for root window. |
| ImRect InnerRect; |
| int LastFrameActive; |
| float ItemWidthDefault; |
| ImGuiSimpleColumns MenuColumns; // Simplified columns storage for menu items |
| ImGuiStorage StateStorage; |
| ImVector<ImGuiColumnsSet> ColumnsStorage; |
| float FontWindowScale; // Scale multiplier per-window |
| ImDrawList* DrawList; |
| ImGuiWindow* ParentWindow; // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL. |
| ImGuiWindow* RootWindow; // Generally point to ourself. If we are a child window, this is pointing to the first non-child parent window. |
| ImGuiWindow* RootNonPopupWindow; // Generally point to ourself. Used to display TitleBgActive color and for selecting which window to use for NavWindowing |
| |
| // Navigation / Focus |
| int FocusIdxAllCounter; // Start at -1 and increase as assigned via FocusItemRegister() |
| int FocusIdxTabCounter; // (same, but only count widgets which you can Tab through) |
| int FocusIdxAllRequestCurrent; // Item being requested for focus |
| int FocusIdxTabRequestCurrent; // Tab-able item being requested for focus |
| 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) |
| int FocusIdxTabRequestNext; // " |
| |
| public: |
| ImGuiWindow(ImGuiContext* context, const char* name); |
| ~ImGuiWindow(); |
| |
| ImGuiID GetID(const char* str, const char* str_end = NULL); |
| ImGuiID GetID(const void* ptr); |
| ImGuiID GetIDNoKeepAlive(const char* str, const char* str_end = NULL); |
| ImGuiID GetIDFromRectangle(const ImRect& r_abs); |
| |
| // We don't use g.FontSize because the window may be != g.CurrentWidow. |
| ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x+Size.x, Pos.y+Size.y); } |
| float CalcFontSize() const { return GImGui->FontBaseSize * FontWindowScale; } |
| float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f; } |
| ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); } |
| float MenuBarHeight() const { return (Flags & ImGuiWindowFlags_MenuBar) ? CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f : 0.0f; } |
| ImRect MenuBarRect() const { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); } |
| }; |
| |
| // 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. |
| struct ImGuiItemHoveredDataBackup |
| { |
| ImGuiID LastItemId; |
| ImRect LastItemRect; |
| bool LastItemRectHoveredRect; |
| |
| ImGuiItemHoveredDataBackup() { Backup(); } |
| void Backup() { ImGuiWindow* window = GImGui->CurrentWindow; LastItemId = window->DC.LastItemId; LastItemRect = window->DC.LastItemRect; LastItemRectHoveredRect = window->DC.LastItemRectHoveredRect; } |
| void Restore() const { ImGuiWindow* window = GImGui->CurrentWindow; window->DC.LastItemId = LastItemId; window->DC.LastItemRect = LastItemRect; window->DC.LastItemRectHoveredRect = LastItemRectHoveredRect; } |
| }; |
| |
| //----------------------------------------------------------------------------- |
| // Internal API |
| // No guarantee of forward compatibility here. |
| //----------------------------------------------------------------------------- |
| |
| namespace ImGui |
| { |
| // We should always have a CurrentWindow in the stack (there is an implicit "Debug" window) |
| // If this ever crash because g.CurrentWindow is NULL it means that either |
| // - ImGui::NewFrame() has never been called, which is illegal. |
| // - You are calling ImGui functions after ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal. |
| inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; } |
| inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; } |
| IMGUI_API ImGuiWindow* FindWindowByName(const char* name); |
| IMGUI_API void FocusWindow(ImGuiWindow* window); |
| IMGUI_API void BringWindowToFront(ImGuiWindow* window); |
| IMGUI_API void BringWindowToBack(ImGuiWindow* window); |
| IMGUI_API bool IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent); |
| |
| IMGUI_API void Initialize(); |
| |
| IMGUI_API void MarkIniSettingsDirty(); |
| IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(ImGuiID type_id); |
| IMGUI_API ImGuiWindowSettings* FindWindowSettings(ImGuiID id); |
| |
| IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow* window); |
| IMGUI_API void ClearActiveID(); |
| IMGUI_API void SetHoveredID(ImGuiID id); |
| IMGUI_API void KeepAliveID(ImGuiID id); |
| |
| IMGUI_API void ItemSize(const ImVec2& size, float text_offset_y = 0.0f); |
| IMGUI_API void ItemSize(const ImRect& bb, float text_offset_y = 0.0f); |
| IMGUI_API bool ItemAdd(const ImRect& bb, ImGuiID id); |
| IMGUI_API bool ItemHoverable(const ImRect& bb, ImGuiID id); |
| IMGUI_API bool IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged); |
| IMGUI_API bool FocusableItemRegister(ImGuiWindow* window, ImGuiID id, bool tab_stop = true); // Return true if focus is requested |
| IMGUI_API void FocusableItemUnregister(ImGuiWindow* window); |
| IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_x, float default_y); |
| IMGUI_API float CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x); |
| IMGUI_API void PushMultiItemsWidths(int components, float width_full = 0.0f); |
| IMGUI_API void PushItemFlag(ImGuiItemFlags option, bool enabled); |
| IMGUI_API void PopItemFlag(); |
| |
| IMGUI_API void OpenPopupEx(ImGuiID id, bool reopen_existing); |
| IMGUI_API void ClosePopup(ImGuiID id); |
| IMGUI_API bool IsPopupOpen(ImGuiID id); |
| IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags); |
| IMGUI_API void BeginTooltipEx(ImGuiWindowFlags extra_flags, bool override_previous_tooltip = true); |
| |
| IMGUI_API int CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate); |
| |
| IMGUI_API void Scrollbar(ImGuiLayoutType direction); |
| IMGUI_API void VerticalSeparator(); // Vertical separator, for menu bars (use current line height). not exposed because it is misleading what it doesn't have an effect on regular layout. |
| IMGUI_API bool SplitterBehavior(ImGuiID id, const ImRect& bb, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f); |
| |
| IMGUI_API bool BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id); |
| IMGUI_API void ClearDragDrop(); |
| IMGUI_API bool IsDragDropPayloadBeingAccepted(); |
| |
| // FIXME-WIP: New Columns API |
| 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(). |
| IMGUI_API void EndColumns(); // close columns |
| IMGUI_API void PushColumnClipRect(int column_index = -1); |
| |
| // NB: All position are in absolute pixels coordinates (never using window coordinates internally) |
| // 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. |
| IMGUI_API void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true); |
| IMGUI_API void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width); |
| 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); |
| IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f); |
| IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f); |
| 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); |
| IMGUI_API void RenderTriangle(ImVec2 pos, ImGuiDir dir, float scale = 1.0f); |
| IMGUI_API void RenderBullet(ImVec2 pos); |
| IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col, float sz); |
| IMGUI_API void RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding); |
| IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text. |
| |
| IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0); |
| IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0,0), ImGuiButtonFlags flags = 0); |
| IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos, float radius); |
| IMGUI_API bool ArrowButton(ImGuiID id, ImGuiDir dir, ImVec2 padding, ImGuiButtonFlags flags = 0); |
| |
| 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); |
| IMGUI_API bool SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power); |
| IMGUI_API bool SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* display_format); |
| |
| 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); |
| 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); |
| IMGUI_API bool DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* display_format); |
| |
| 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); |
| IMGUI_API bool InputFloatN(const char* label, float* v, int components, int decimal_precision, ImGuiInputTextFlags extra_flags); |
| IMGUI_API bool InputIntN(const char* label, int* v, int components, ImGuiInputTextFlags extra_flags); |
| 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); |
| IMGUI_API bool InputScalarAsWidgetReplacement(const ImRect& aabb, const char* label, ImGuiDataType data_type, void* data_ptr, ImGuiID id, int decimal_precision); |
| |
| IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags); |
| IMGUI_API void ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags); |
| |
| IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL); |
| IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0); // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging |
| IMGUI_API void TreePushRawID(ImGuiID id); |
| |
| 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); |
| |
| IMGUI_API int ParseFormatPrecision(const char* fmt, int default_value); |
| IMGUI_API float RoundScalar(float value, int decimal_precision); |
| |
| // Shade functions |
| IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawVert* vert_start, ImDrawVert* vert_end, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1); |
| IMGUI_API void ShadeVertsLinearAlphaGradientForLeftToRightText(ImDrawVert* vert_start, ImDrawVert* vert_end, float gradient_p0_x, float gradient_p1_x); |
| IMGUI_API void ShadeVertsLinearUV(ImDrawVert* vert_start, ImDrawVert* vert_end, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp); |
| |
| } // namespace ImGui |
| |
| // ImFontAtlas internals |
| IMGUI_API bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas); |
| IMGUI_API void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas* atlas); |
| IMGUI_API void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent); |
| IMGUI_API void ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* spc); |
| IMGUI_API void ImFontAtlasBuildFinish(ImFontAtlas* atlas); |
| IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor); |
| IMGUI_API void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride); |
| |
| #ifdef __clang__ |
| #pragma clang diagnostic pop |
| #endif |
| |
| #ifdef _MSC_VER |
| #pragma warning (pop) |
| #endif |