blame: source/code/Libs/imgui/imgui_internal.h

// dear imgui, v1.91.4

// (internal structures/api)

// You may use this file to debug, understand or extend Dear ImGui features but we don't provide any guarantee of forward compatibility.

/*

Index of this file:

// [SECTION] Header mess

// [SECTION] Forward declarations

// [SECTION] Context pointer

// [SECTION] STB libraries includes

// [SECTION] Macros

// [SECTION] Generic helpers

// [SECTION] ImDrawList support

// [SECTION] Data types support

// [SECTION] Widgets support: flags, enums, data structures

// [SECTION] Popup support

// [SECTION] Inputs support

// [SECTION] Clipper support

// [SECTION] Navigation support

// [SECTION] Typing-select support

// [SECTION] Columns support

// [SECTION] Box-select support

// [SECTION] Multi-select support

// [SECTION] Docking support

// [SECTION] Viewport support

// [SECTION] Settings support

// [SECTION] Localization support

// [SECTION] Error handling, State recovery support

// [SECTION] Metrics, Debug tools

// [SECTION] Generic context hooks

// [SECTION] ImGuiContext (main imgui context)

// [SECTION] ImGuiWindowTempData, ImGuiWindow

// [SECTION] Tab bar, Tab item support

// [SECTION] Table support

// [SECTION] ImGui internal API

// [SECTION] ImFontAtlas internal API

// [SECTION] Test Engine specific hooks (imgui_test_engine)

*/

#pragma once

#ifndef IMGUI_DISABLE

//-----------------------------------------------------------------------------

// [SECTION] Header mess

//-----------------------------------------------------------------------------

#ifndef IMGUI_VERSION

#include "imgui.h"

#endif

#include <stdio.h>      // FILE*, sscanf

#include <stdlib.h>     // NULL, malloc, free, qsort, atoi, atof

#include <math.h>       // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf

#include <limits.h>     // INT_MIN, INT_MAX

// Enable SSE intrinsics if available

#if (defined __SSE__ || defined __x86_64__ || defined _M_X64 || (defined(_M_IX86_FP) && (_M_IX86_FP >= 1))) && !defined(IMGUI_DISABLE_SSE)

#define IMGUI_ENABLE_SSE

#include <immintrin.h>

#endif

// Visual Studio warnings

#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)

#pragma warning (disable: 26812)    // The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3). [MSVC Static Analyzer)

#pragma warning (disable: 26495)    // [Static Analyzer] Variable 'XXX' is uninitialized. Always initialize a member variable (type.6).

#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later

#pragma warning (disable: 5054)     // operator '|': deprecated between enumerations of different types

#endif

#endif

// Clang/GCC warnings with -Weverything

#if defined(__clang__)

#pragma clang diagnostic push

#if __has_warning("-Wunknown-warning-option")

#pragma clang diagnostic ignored "-Wunknown-warning-option"         // warning: unknown warning group 'xxx'

#endif

#pragma clang diagnostic ignored "-Wunknown-pragmas"                // warning: unknown warning group 'xxx'

#pragma clang diagnostic ignored "-Wfloat-equal"                    // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants ok, for ImFloor()

#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"

#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"

#pragma clang diagnostic ignored "-Wdouble-promotion"

#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"  // warning: implicit conversion from 'xxx' to 'float' may lose precision

#pragma clang diagnostic ignored "-Wmissing-noreturn"               // warning: function 'xxx' could be declared with attribute 'noreturn'

#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"// warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated

#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"            // warning: 'xxx' is an unsafe pointer used for buffer access

#elif defined(__GNUC__)

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wpragmas"                          // warning: unknown option after '#pragma GCC diagnostic' kind

#pragma GCC diagnostic ignored "-Wclass-memaccess"                  // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead

#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion"  // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated

#endif

// In 1.89.4, we moved the implementation of "courtesy maths operators" from imgui_internal.h in imgui.h

// As they are frequently requested, we do not want to encourage to many people using imgui_internal.h

#if defined(IMGUI_DEFINE_MATH_OPERATORS) && !defined(IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED)

#error Please '#define IMGUI_DEFINE_MATH_OPERATORS' _BEFORE_ including imgui.h!

#endif

// Legacy defines

#ifdef IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS            // Renamed in 1.74

#error Use IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS

#endif

#ifdef IMGUI_DISABLE_MATH_FUNCTIONS                     // Renamed in 1.74

#error Use IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS

#endif

// Enable stb_truetype by default unless FreeType is enabled.

// You can compile with both by defining both IMGUI_ENABLE_FREETYPE and IMGUI_ENABLE_STB_TRUETYPE together.

#ifndef IMGUI_ENABLE_FREETYPE

#define IMGUI_ENABLE_STB_TRUETYPE

#endif

//-----------------------------------------------------------------------------

// [SECTION] Forward declarations

//-----------------------------------------------------------------------------

struct ImBitVector;                 // Store 1-bit per value

struct ImRect;                      // An axis-aligned rectangle (2 points)

struct ImDrawDataBuilder;           // Helper to build a ImDrawData instance

struct ImDrawListSharedData;        // Data shared between all ImDrawList instances

struct ImGuiBoxSelectState;         // Box-selection state (currently used by multi-selection, could potentially be used by others)

struct ImGuiColorMod;               // Stacked color modifier, backup of modified data so we can restore it

struct ImGuiContext;                // Main Dear ImGui context

struct ImGuiContextHook;            // Hook for extensions like ImGuiTestEngine

struct ImGuiDataVarInfo;            // Variable information (e.g. to access style variables from an enum)

struct ImGuiDataTypeInfo;           // Type information associated to a ImGuiDataType enum

struct ImGuiDockContext;            // Docking system context

struct ImGuiDockRequest;            // Docking system dock/undock queued request

struct ImGuiDockNode;               // Docking system node (hold a list of Windows OR two child dock nodes)

struct ImGuiDockNodeSettings;       // Storage for a dock node in .ini file (we preserve those even if the associated dock node isn't active during the session)

struct ImGuiErrorRecoveryState;     // Storage of stack sizes for error handling and recovery

struct ImGuiGroupData;              // Stacked storage data for BeginGroup()/EndGroup()

struct ImGuiInputTextState;         // Internal state of the currently focused/edited text input box

struct ImGuiInputTextDeactivateData;// Short term storage to backup text of a deactivating InputText() while another is stealing active id

struct ImGuiLastItemData;           // Status storage for last submitted items

struct ImGuiLocEntry;               // A localization entry.

struct ImGuiMenuColumns;            // Simple column measurement, currently used for MenuItem() only

struct ImGuiMultiSelectState;       // Multi-selection persistent state (for focused selection).

struct ImGuiMultiSelectTempData;    // Multi-selection temporary state (while traversing).

struct ImGuiNavItemData;            // Result of a keyboard/gamepad directional navigation move query result

struct ImGuiMetricsConfig;          // Storage for ShowMetricsWindow() and DebugNodeXXX() functions

struct ImGuiNextWindowData;         // Storage for SetNextWindow** functions

struct ImGuiNextItemData;           // Storage for SetNextItem** functions

struct ImGuiOldColumnData;          // Storage data for a single column for legacy Columns() api

struct ImGuiOldColumns;             // Storage data for a columns set for legacy Columns() api

struct ImGuiPopupData;              // Storage for current popup stack

struct ImGuiSettingsHandler;        // Storage for one type registered in the .ini file

struct ImGuiStyleMod;               // Stacked style modifier, backup of modified data so we can restore it

struct ImGuiTabBar;                 // Storage for a tab bar

struct ImGuiTabItem;                // Storage for a tab item (within a tab bar)

struct ImGuiTable;                  // Storage for a table

struct ImGuiTableHeaderData;        // Storage for TableAngledHeadersRow()

struct ImGuiTableColumn;            // Storage for one column of a table

struct ImGuiTableInstanceData;      // Storage for one instance of a same table

struct ImGuiTableTempData;          // Temporary storage for one table (one per table in the stack), shared between tables.

struct ImGuiTableSettings;          // Storage for a table .ini settings

struct ImGuiTableColumnsSettings;   // Storage for a column .ini settings

struct ImGuiTreeNodeStackData;      // Temporary storage for TreeNode().

struct ImGuiTypingSelectState;      // Storage for GetTypingSelectRequest()

struct ImGuiTypingSelectRequest;    // Storage for GetTypingSelectRequest() (aimed to be public)

struct ImGuiWindow;                 // Storage for one window

struct ImGuiWindowDockStyle;        // Storage for window-style data which needs to be stored for docking purpose

struct ImGuiWindowTempData;         // Temporary storage for one window (that's the data which in theory we could ditch at the end of the frame, in practice we currently keep it for each window)

struct ImGuiWindowSettings;         // Storage for a window .ini settings (we keep one of those even if the actual window wasn't instanced during this session)

// Enumerations

// Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.

enum ImGuiLocKey : int;                 // -> enum ImGuiLocKey              // Enum: a localization entry for translation.

typedef int ImGuiDataAuthority;         // -> enum ImGuiDataAuthority_      // Enum: for storing the source authority (dock node vs window) of a field

typedef int ImGuiLayoutType;            // -> enum ImGuiLayoutType_         // Enum: Horizontal or vertical

// Flags

typedef int ImGuiActivateFlags;         // -> enum ImGuiActivateFlags_      // Flags: for navigation/focus function (will be for ActivateItem() later)

typedef int ImGuiDebugLogFlags;         // -> enum ImGuiDebugLogFlags_      // Flags: for ShowDebugLogWindow(), g.DebugLogFlags

typedef int ImGuiFocusRequestFlags;     // -> enum ImGuiFocusRequestFlags_  // Flags: for FocusWindow()

typedef int ImGuiItemStatusFlags;       // -> enum ImGuiItemStatusFlags_    // Flags: for g.LastItemData.StatusFlags

typedef int ImGuiOldColumnFlags;        // -> enum ImGuiOldColumnFlags_     // Flags: for BeginColumns()

typedef int ImGuiNavRenderCursorFlags;  // -> enum ImGuiNavRenderCursorFlags_//Flags: for RenderNavCursor()

typedef int ImGuiNavMoveFlags;          // -> enum ImGuiNavMoveFlags_       // Flags: for navigation requests

typedef int ImGuiNextItemDataFlags;     // -> enum ImGuiNextItemDataFlags_  // Flags: for SetNextItemXXX() functions

typedef int ImGuiNextWindowDataFlags;   // -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions

typedef int ImGuiScrollFlags;           // -> enum ImGuiScrollFlags_        // Flags: for ScrollToItem() and navigation requests

typedef int ImGuiSeparatorFlags;        // -> enum ImGuiSeparatorFlags_     // Flags: for SeparatorEx()

typedef int ImGuiTextFlags;             // -> enum ImGuiTextFlags_          // Flags: for TextEx()

typedef int ImGuiTooltipFlags;          // -> enum ImGuiTooltipFlags_       // Flags: for BeginTooltipEx()

typedef int ImGuiTypingSelectFlags;     // -> enum ImGuiTypingSelectFlags_  // Flags: for GetTypingSelectRequest()

typedef int ImGuiWindowRefreshFlags;    // -> enum ImGuiWindowRefreshFlags_ // Flags: for SetNextWindowRefreshPolicy()

//-----------------------------------------------------------------------------

// [SECTION] Context pointer

// See implementation of this variable in imgui.cpp for comments and details.

//-----------------------------------------------------------------------------

#ifndef GImGui

extern IMGUI_API ImGuiContext* GImGui;  // Current implicit context pointer

#endif

//-----------------------------------------------------------------------------

// [SECTION] Macros

//-----------------------------------------------------------------------------

// Internal Drag and Drop payload types. String starting with '_' are reserved for Dear ImGui.

#define IMGUI_PAYLOAD_TYPE_WINDOW       "_IMWINDOW"     // Payload == ImGuiWindow*

// Debug Printing Into TTY

// (since IMGUI_VERSION_NUM >= 18729: IMGUI_DEBUG_LOG was reworked into IMGUI_DEBUG_PRINTF (and removed framecount from it). If you were using a #define IMGUI_DEBUG_LOG please rename)

#ifndef IMGUI_DEBUG_PRINTF

#ifndef IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS

#define IMGUI_DEBUG_PRINTF(_FMT,...)    printf(_FMT, __VA_ARGS__)

#else

#define IMGUI_DEBUG_PRINTF(_FMT,...)    ((void)0)

#endif

#endif

// Debug Logging for ShowDebugLogWindow(). This is designed for relatively rare events so please don't spam.

#ifndef IMGUI_DISABLE_DEBUG_TOOLS

#define IMGUI_DEBUG_LOG(...)            ImGui::DebugLog(__VA_ARGS__)

#else

#define IMGUI_DEBUG_LOG(...)            ((void)0)

#endif

#define IMGUI_DEBUG_LOG_ERROR(...)      do { ImGuiContext& g2 = *GImGui; if (g2.DebugLogFlags & ImGuiDebugLogFlags_EventError) IMGUI_DEBUG_LOG(__VA_ARGS__); else g2.DebugLogSkippedErrors++; } while (0)

#define IMGUI_DEBUG_LOG_ACTIVEID(...)   do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventActiveId)    IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_FOCUS(...)      do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventFocus)       IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_POPUP(...)      do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventPopup)       IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_NAV(...)        do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventNav)         IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_SELECTION(...)  do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection)   IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_CLIPPER(...)    do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventClipper)     IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_IO(...)         do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventIO)          IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_INPUTROUTING(...) do{if (g.DebugLogFlags & ImGuiDebugLogFlags_EventInputRouting)IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_DOCKING(...)    do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventDocking)     IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_VIEWPORT(...)   do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventViewport)    IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

// Static Asserts

#define IM_STATIC_ASSERT(_COND)         static_assert(_COND, "")

// "Paranoid" Debug Asserts are meant to only be enabled during specific debugging/work, otherwise would slow down the code too much.

// We currently don't have many of those so the effect is currently negligible, but onward intent to add more aggressive ones in the code.

//#define IMGUI_DEBUG_PARANOID

#ifdef IMGUI_DEBUG_PARANOID

#define IM_ASSERT_PARANOID(_EXPR)       IM_ASSERT(_EXPR)

#else

#define IM_ASSERT_PARANOID(_EXPR)

#endif

// Misc Macros

#define IM_PI                           3.14159265358979323846f

#ifdef _WIN32

#define IM_NEWLINE                      "\r\n"   // Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!)

#else

#define IM_NEWLINE                      "\n"

#endif

#ifndef IM_TABSIZE                      // Until we move this to runtime and/or add proper tab support, at least allow users to compile-time override

#define IM_TABSIZE                      (4)

#endif

#define IM_MEMALIGN(_OFF,_ALIGN)        (((_OFF) + ((_ALIGN) - 1)) & ~((_ALIGN) - 1))           // Memory align e.g. IM_ALIGN(0,4)=0, IM_ALIGN(1,4)=4, IM_ALIGN(4,4)=4, IM_ALIGN(5,4)=8

#define IM_F32_TO_INT8_UNBOUND(_VAL)    ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f)))   // Unsaturated, for display purpose

#define IM_F32_TO_INT8_SAT(_VAL)        ((int)(ImSaturate(_VAL) * 255.0f + 0.5f))               // Saturated, always output 0..255

#define IM_TRUNC(_VAL)                  ((float)(int)(_VAL))                                    // ImTrunc() is not inlined in MSVC debug builds

#define IM_ROUND(_VAL)                  ((float)(int)((_VAL) + 0.5f))                           //

#define IM_STRINGIFY_HELPER(_X)         #_X

#define IM_STRINGIFY(_X)                IM_STRINGIFY_HELPER(_X)                                 // Preprocessor idiom to stringify e.g. an integer.

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

#define IM_FLOOR IM_TRUNC

#endif

// Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall

#ifdef _MSC_VER

#define IMGUI_CDECL __cdecl

#else

#define IMGUI_CDECL

#endif

// Warnings

#if defined(_MSC_VER) && !defined(__clang__)

#define IM_MSVC_WARNING_SUPPRESS(XXXX)  __pragma(warning(suppress: XXXX))

#else

#define IM_MSVC_WARNING_SUPPRESS(XXXX)

#endif

// Debug Tools

// Use 'Metrics/Debugger->Tools->Item Picker' to break into the call-stack of a specific item.

// This will call IM_DEBUG_BREAK() which you may redefine yourself. See https://github.com/scottt/debugbreak for more reference.

#ifndef IM_DEBUG_BREAK

#if defined (_MSC_VER)

#define IM_DEBUG_BREAK()    __debugbreak()

#elif defined(__clang__)

#define IM_DEBUG_BREAK()    __builtin_debugtrap()

#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))

#define IM_DEBUG_BREAK()    __asm__ volatile("int3;nop")

#elif defined(__GNUC__) && defined(__thumb__)

#define IM_DEBUG_BREAK()    __asm__ volatile(".inst 0xde01")

#elif defined(__GNUC__) && defined(__arm__) && !defined(__thumb__)

#define IM_DEBUG_BREAK()    __asm__ volatile(".inst 0xe7f001f0")

#else

#define IM_DEBUG_BREAK()    IM_ASSERT(0)    // It is expected that you define IM_DEBUG_BREAK() into something that will break nicely in a debugger!

#endif

#endif // #ifndef IM_DEBUG_BREAK

// Format specifiers, printing 64-bit hasn't been decently standardized...

// In a real application you should be using PRId64 and PRIu64 from <inttypes.h> (non-windows) and on Windows define them yourself.

#if defined(_MSC_VER) && !defined(__clang__)

#define IM_PRId64   "I64d"

#define IM_PRIu64   "I64u"

#define IM_PRIX64   "I64X"

#else

#define IM_PRId64   "lld"

#define IM_PRIu64   "llu"

#define IM_PRIX64   "llX"

#endif

//-----------------------------------------------------------------------------

// [SECTION] Generic helpers

// Note that the ImXXX helpers functions are lower-level than ImGui functions.

// ImGui functions or the ImGui context are never called/used from other ImXXX functions.

//-----------------------------------------------------------------------------

// - Helpers: Hashing

// - Helpers: Sorting

// - Helpers: Bit manipulation

// - Helpers: String

// - Helpers: Formatting

// - Helpers: UTF-8 <> wchar conversions

// - Helpers: ImVec2/ImVec4 operators

// - Helpers: Maths

// - Helpers: Geometry

// - Helper: ImVec1

// - Helper: ImVec2ih

// - Helper: ImRect

// - Helper: ImBitArray

// - Helper: ImBitVector

// - Helper: ImSpan<>, ImSpanAllocator<>

// - Helper: ImPool<>

// - Helper: ImChunkStream<>

// - Helper: ImGuiTextIndex

// - Helper: ImGuiStorage

//-----------------------------------------------------------------------------

// Helpers: Hashing

IMGUI_API ImGuiID       ImHashData(const void* data, size_t data_size, ImGuiID seed = 0);

IMGUI_API ImGuiID       ImHashStr(const char* data, size_t data_size = 0, ImGuiID seed = 0);

// Helpers: Sorting

#ifndef ImQsort

static inline void      ImQsort(void* base, size_t count, size_t size_of_element, int(IMGUI_CDECL *compare_func)(void const*, void const*)) { if (count > 1) qsort(base, count, size_of_element, compare_func); }

#endif

// Helpers: Color Blending

IMGUI_API ImU32         ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);

// Helpers: Bit manipulation

static inline bool      ImIsPowerOfTwo(int v)           { return v != 0 && (v & (v - 1)) == 0; }

static inline bool      ImIsPowerOfTwo(ImU64 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: String

IMGUI_API int           ImStricmp(const char* str1, const char* str2);                      // Case insensitive compare.

IMGUI_API int           ImStrnicmp(const char* str1, const char* str2, size_t count);       // Case insensitive compare to a certain count.

IMGUI_API void          ImStrncpy(char* dst, const char* src, size_t count);                // Copy to a certain count and always zero terminate (strncpy doesn't).

IMGUI_API char*         ImStrdup(const char* str);                                          // Duplicate a string.

IMGUI_API char*         ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str);        // Copy in provided buffer, recreate buffer if needed.

IMGUI_API const char*   ImStrchrRange(const char* str_begin, const char* str_end, char c);  // Find first occurrence of 'c' in string range.

IMGUI_API const char*   ImStreolRange(const char* str, const char* str_end);                // End end-of-line

IMGUI_API const char*   ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);  // Find a substring in a string range.

IMGUI_API void          ImStrTrimBlanks(char* str);                                         // Remove leading and trailing blanks from a buffer.

IMGUI_API const char*   ImStrSkipBlank(const char* str);                                    // Find first non-blank character.

IMGUI_API int           ImStrlenW(const ImWchar* str);                                      // Computer string length (ImWchar string)

IMGUI_API const char*   ImStrbol(const char* buf_mid_line, const char* buf_begin);          // Find beginning-of-line

IM_MSVC_RUNTIME_CHECKS_OFF

static inline char      ImToUpper(char c)               { return (c >= 'a' && c <= 'z') ? c &= ~32 : c; }

static inline bool      ImCharIsBlankA(char c)          { return c == ' ' || c == '\t'; }

static inline bool      ImCharIsBlankW(unsigned int c)  { return c == ' ' || c == '\t' || c == 0x3000; }

static inline bool      ImCharIsXdigitA(char c)         { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); }

IM_MSVC_RUNTIME_CHECKS_RESTORE

// Helpers: Formatting

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);

IMGUI_API void          ImFormatStringToTempBuffer(const char** out_buf, const char** out_buf_end, const char* fmt, ...) IM_FMTARGS(3);

IMGUI_API void          ImFormatStringToTempBufferV(const char** out_buf, const char** out_buf_end, const char* fmt, va_list args) IM_FMTLIST(3);

IMGUI_API const char*   ImParseFormatFindStart(const char* format);

IMGUI_API const char*   ImParseFormatFindEnd(const char* format);

IMGUI_API const char*   ImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size);

IMGUI_API void          ImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size);

IMGUI_API const char*   ImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size);

IMGUI_API int           ImParseFormatPrecision(const char* format, int default_value);

// Helpers: UTF-8 <> wchar conversions

IMGUI_API const char*   ImTextCharToUtf8(char out_buf[5], unsigned int c);                                                      // return out_buf

IMGUI_API int           ImTextStrToUtf8(char* out_buf, int out_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);               // read one character. return input UTF-8 bytes count

IMGUI_API int           ImTextStrFromUtf8(ImWchar* out_buf, int out_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           ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end);                             // return number of bytes to express one char in UTF-8

IMGUI_API int           ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end);                        // return number of bytes to express string in UTF-8

IMGUI_API const char*   ImTextFindPreviousUtf8Codepoint(const char* in_text_start, const char* in_text_curr);                   // return previous UTF-8 code-point.

IMGUI_API int           ImTextCountLines(const char* in_text, const char* in_text_end);                                         // return number of lines taken by text. trailing carriage return doesn't count as an extra line.

// Helpers: File System

#ifdef IMGUI_DISABLE_FILE_FUNCTIONS

#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS

typedef void* ImFileHandle;

static inline ImFileHandle  ImFileOpen(const char*, const char*)                    { return NULL; }

static inline bool          ImFileClose(ImFileHandle)                               { return false; }

static inline ImU64         ImFileGetSize(ImFileHandle)                             { return (ImU64)-1; }

static inline ImU64         ImFileRead(void*, ImU64, ImU64, ImFileHandle)           { return 0; }

static inline ImU64         ImFileWrite(const void*, ImU64, ImU64, ImFileHandle)    { return 0; }

#endif

#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS

typedef FILE* ImFileHandle;

IMGUI_API ImFileHandle      ImFileOpen(const char* filename, const char* mode);

IMGUI_API bool              ImFileClose(ImFileHandle file);

IMGUI_API ImU64             ImFileGetSize(ImFileHandle file);

IMGUI_API ImU64             ImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file);

IMGUI_API ImU64             ImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file);

#else

#define IMGUI_DISABLE_TTY_FUNCTIONS // Can't use stdout, fflush if we are not using default file functions

#endif

IMGUI_API void*             ImFileLoadToMemory(const char* filename, const char* mode, size_t* out_file_size = NULL, int padding_bytes = 0);

// Helpers: Maths

IM_MSVC_RUNTIME_CHECKS_OFF

// - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)

#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS

#define ImFabs(X)           fabsf(X)

#define ImSqrt(X)           sqrtf(X)

#define ImFmod(X, Y)        fmodf((X), (Y))

#define ImCos(X)            cosf(X)

#define ImSin(X)            sinf(X)

#define ImAcos(X)           acosf(X)

#define ImAtan2(Y, X)       atan2f((Y), (X))

#define ImAtof(STR)         atof(STR)

#define ImCeil(X)           ceilf(X)

static inline float  ImPow(float x, float y)    { return powf(x, y); }          // DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision

static inline double ImPow(double x, double y)  { return pow(x, y); }

static inline float  ImLog(float x)             { return logf(x); }             // DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision

static inline double ImLog(double x)            { return log(x); }

static inline int    ImAbs(int x)               { return x < 0 ? -x : x; }

static inline float  ImAbs(float x)             { return fabsf(x); }

static inline double ImAbs(double x)            { return fabs(x); }

static inline float  ImSign(float x)            { return (x < 0.0f) ? -1.0f : (x > 0.0f) ? 1.0f : 0.0f; } // Sign operator - returns -1, 0 or 1 based on sign of argument

static inline double ImSign(double x)           { return (x < 0.0) ? -1.0 : (x > 0.0) ? 1.0 : 0.0; }

#ifdef IMGUI_ENABLE_SSE

static inline float  ImRsqrt(float x)           { return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x))); }

#else

static inline float  ImRsqrt(float x)           { return 1.0f / sqrtf(x); }

#endif

static inline double ImRsqrt(double x)          { return 1.0 / sqrt(x); }

#endif

// - ImMin/ImMax/ImClamp/ImLerp/ImSwap are used by widgets which support variety of types: signed/unsigned int/long long float/double

// (Exceptionally using templates here but we could also redefine them for those types)

template<typename T> static inline T ImMin(T lhs, T rhs)                        { return lhs < rhs ? lhs : rhs; }

template<typename T> static inline T ImMax(T lhs, T rhs)                        { return lhs >= rhs ? lhs : rhs; }

template<typename T> static inline T ImClamp(T v, T mn, T mx)                   { return (v < mn) ? mn : (v > mx) ? mx : v; }

template<typename T> static inline T ImLerp(T a, T b, float t)                  { return (T)(a + (b - a) * t); }

template<typename T> static inline void ImSwap(T& a, T& b)                      { T tmp = a; a = b; b = tmp; }

template<typename T> static inline T ImAddClampOverflow(T a, T b, T mn, T mx)   { if (b < 0 && (a < mn - b)) return mn; if (b > 0 && (a > mx - b)) return mx; return a + b; }

template<typename T> static inline T ImSubClampOverflow(T a, T b, T mn, T mx)   { if (b > 0 && (a < mn + b)) return mn; if (b < 0 && (a > mx + b)) return mx; return a - b; }

// - Misc maths helpers

static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }

static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }

static inline ImVec2 ImClamp(const ImVec2& v, const ImVec2&mn, const ImVec2&mx) { return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }

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  ImSaturate(float f)                                        { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }

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 ImRsqrt(d); return fail_value; }

static inline float  ImTrunc(float f)                                           { return (float)(int)(f); }

static inline ImVec2 ImTrunc(const ImVec2& v)                                   { return ImVec2((float)(int)(v.x), (float)(int)(v.y)); }

static inline float  ImFloor(float f)                                           { return (float)((f >= 0 || (float)(int)f == f) ? (int)f : (int)f - 1); } // Decent replacement for floorf()

static inline ImVec2 ImFloor(const ImVec2& v)                                   { return ImVec2(ImFloor(v.x), ImFloor(v.y)); }

static inline int    ImModPositive(int a, int b)                                { return (a + b) % b; }

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 float  ImLinearRemapClamp(float s0, float s1, float d0, float d1, float x) { return ImSaturate((x - s0) / (s1 - s0)) * (d1 - d0) + d0; }

static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }

static inline bool   ImIsFloatAboveGuaranteedIntegerPrecision(float f)          { return f <= -16777216 || f >= 16777216; }

static inline float  ImExponentialMovingAverage(float avg, float sample, int n) { avg -= avg / n; avg += sample / n; return avg; }

IM_MSVC_RUNTIME_CHECKS_RESTORE

// Helpers: Geometry

IMGUI_API ImVec2     ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t);

IMGUI_API ImVec2     ImBezierCubicClosestPoint(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& p, int num_segments);       // For curves with explicit number of segments

IMGUI_API ImVec2     ImBezierCubicClosestPointCasteljau(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& p, float tess_tol);// For auto-tessellated curves you can use tess_tol = style.CurveTessellationTol

IMGUI_API ImVec2     ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, float t);

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);

inline float         ImTriangleArea(const ImVec2& a, const ImVec2& b, const ImVec2& c)          { return ImFabs((a.x * (b.y - c.y)) + (b.x * (c.y - a.y)) + (c.x * (a.y - b.y))) * 0.5f; }

inline bool          ImTriangleIsClockwise(const ImVec2& a, const ImVec2& b, const ImVec2& c)   { return ((b.x - a.x) * (c.y - b.y)) - ((c.x - b.x) * (b.y - a.y)) > 0.0f; }

// Helper: ImVec1 (1D vector)

// (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches)

IM_MSVC_RUNTIME_CHECKS_OFF

struct ImVec1

{

    float   x;

    constexpr ImVec1()         : x(0.0f) { }

    constexpr ImVec1(float _x) : x(_x) { }

};

// Helper: ImVec2ih (2D vector, half-size integer, for long-term packed storage)

struct ImVec2ih

{

    short   x, y;

    constexpr ImVec2ih()                           : x(0), y(0) {}

    constexpr ImVec2ih(short _x, short _y)         : x(_x), y(_y) {}

    constexpr explicit ImVec2ih(const ImVec2& rhs) : x((short)rhs.x), y((short)rhs.y) {}

};

// Helper: ImRect (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

    constexpr ImRect()                                        : Min(0.0f, 0.0f), Max(0.0f, 0.0f)  {}

    constexpr ImRect(const ImVec2& min, const ImVec2& max)    : Min(min), Max(max)                {}

    constexpr ImRect(const ImVec4& v)                         : Min(v.x, v.y), Max(v.z, v.w)      {}

    constexpr 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; }

    float       GetArea() const                     { return (Max.x - Min.x) * (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        ContainsWithPad(const ImVec2& p, const ImVec2& pad) const { return p.x >= Min.x - pad.x && p.y >= Min.y - pad.y && p.x < Max.x + pad.x && p.y < Max.y + pad.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& p)                { if (Min.x > p.x)     Min.x = p.x;     if (Min.y > p.y)     Min.y = p.y;     if (Max.x < p.x)     Max.x = p.x;     if (Max.y < p.y)     Max.y = p.y; }

    void        Add(const ImRect& r)                { if (Min.x > r.Min.x) Min.x = r.Min.x; if (Min.y > r.Min.y) Min.y = r.Min.y; if (Max.x < r.Max.x) Max.x = r.Max.x; if (Max.y < r.Max.y) Max.y = r.Max.y; }

    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& d)          { Min.x += d.x; Min.y += d.y; Max.x += d.x; Max.y += d.y; }

    void        TranslateX(float dx)                { Min.x += dx; Max.x += dx; }

    void        TranslateY(float dy)                { Min.y += dy; Max.y += dy; }

    void        ClipWith(const ImRect& r)           { Min = ImMax(Min, r.Min); Max = ImMin(Max, r.Max); }                   // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.

    void        ClipWithFull(const ImRect& r)       { Min = ImClamp(Min, r.Min, r.Max); Max = ImClamp(Max, r.Min, r.Max); } // Full version, ensure both points are fully clipped.

    void        Floor()                             { Min.x = IM_TRUNC(Min.x); Min.y = IM_TRUNC(Min.y); Max.x = IM_TRUNC(Max.x); Max.y = IM_TRUNC(Max.y); }

    bool        IsInverted() const                  { return Min.x > Max.x || Min.y > Max.y; }

    ImVec4      ToVec4() const                      { return ImVec4(Min.x, Min.y, Max.x, Max.y); }

};

// Helper: ImBitArray

#define         IM_BITARRAY_TESTBIT(_ARRAY, _N)                 ((_ARRAY[(_N) >> 5] & ((ImU32)1 << ((_N) & 31))) != 0) // Macro version of ImBitArrayTestBit(): ensure args have side-effect or are costly!

#define         IM_BITARRAY_CLEARBIT(_ARRAY, _N)                ((_ARRAY[(_N) >> 5] &= ~((ImU32)1 << ((_N) & 31))))    // Macro version of ImBitArrayClearBit(): ensure args have side-effect or are costly!

inline size_t   ImBitArrayGetStorageSizeInBytes(int bitcount)   { return (size_t)((bitcount + 31) >> 5) << 2; }

inline void     ImBitArrayClearAllBits(ImU32* arr, int bitcount){ memset(arr, 0, ImBitArrayGetStorageSizeInBytes(bitcount)); }

inline bool     ImBitArrayTestBit(const ImU32* arr, int n)      { ImU32 mask = (ImU32)1 << (n & 31); return (arr[n >> 5] & mask) != 0; }

inline void     ImBitArrayClearBit(ImU32* arr, int n)           { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] &= ~mask; }

inline void     ImBitArraySetBit(ImU32* arr, int n)             { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] |= mask; }

inline void     ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Works on range [n..n2)

{

    n2--;

    while (n <= n2)

    {

        int a_mod = (n & 31);

        int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;

        ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);

        arr[n >> 5] |= mask;

        n = (n + 32) & ~31;

    }

}

typedef ImU32* ImBitArrayPtr; // Name for use in structs

// Helper: ImBitArray class (wrapper over ImBitArray functions)

// Store 1-bit per value.

template<int BITCOUNT, int OFFSET = 0>

struct ImBitArray

{

    ImU32           Storage[(BITCOUNT + 31) >> 5];

    ImBitArray()                                { ClearAllBits(); }

    void            ClearAllBits()              { memset(Storage, 0, sizeof(Storage)); }

    void            SetAllBits()                { memset(Storage, 255, sizeof(Storage)); }

    bool            TestBit(int n) const        { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); return IM_BITARRAY_TESTBIT(Storage, n); }

    void            SetBit(int n)               { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArraySetBit(Storage, n); }

    void            ClearBit(int n)             { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArrayClearBit(Storage, n); }

    void            SetBitRange(int n, int n2)  { n += OFFSET; n2 += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT && n2 > n && n2 <= BITCOUNT); ImBitArraySetBitRange(Storage, n, n2); } // Works on range [n..n2)

    bool            operator[](int n) const     { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); return IM_BITARRAY_TESTBIT(Storage, n); }

};

// Helper: ImBitVector

// Store 1-bit per value.

struct IMGUI_API ImBitVector

{

    ImVector<ImU32> Storage;

    void            Create(int sz)              { Storage.resize((sz + 31) >> 5); memset(Storage.Data, 0, (size_t)Storage.Size * sizeof(Storage.Data[0])); }

    void            Clear()                     { Storage.clear(); }

    bool            TestBit(int n) const        { IM_ASSERT(n < (Storage.Size << 5)); return IM_BITARRAY_TESTBIT(Storage.Data, n); }

    void            SetBit(int n)               { IM_ASSERT(n < (Storage.Size << 5)); ImBitArraySetBit(Storage.Data, n); }

    void            ClearBit(int n)             { IM_ASSERT(n < (Storage.Size << 5)); ImBitArrayClearBit(Storage.Data, n); }

};

IM_MSVC_RUNTIME_CHECKS_RESTORE

// Helper: ImSpan<>

// Pointing to a span of data we don't own.

template<typename T>

struct ImSpan

{

    T*                  Data;

    T*                  DataEnd;

    // Constructors, destructor

    inline ImSpan()                                 { Data = DataEnd = NULL; }

    inline ImSpan(T* data, int size)                { Data = data; DataEnd = data + size; }

    inline ImSpan(T* data, T* data_end)             { Data = data; DataEnd = data_end; }

    inline void         set(T* data, int size)      { Data = data; DataEnd = data + size; }

    inline void         set(T* data, T* data_end)   { Data = data; DataEnd = data_end; }

    inline int          size() const                { return (int)(ptrdiff_t)(DataEnd - Data); }

    inline int          size_in_bytes() const       { return (int)(ptrdiff_t)(DataEnd - Data) * (int)sizeof(T); }

    inline T&           operator[](int i)           { T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }

    inline const T&     operator[](int i) const     { const T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }

    inline T*           begin()                     { return Data; }

    inline const T*     begin() const               { return Data; }

    inline T*           end()                       { return DataEnd; }

    inline const T*     end() const                 { return DataEnd; }

    // Utilities

    inline int  index_from_ptr(const T* it) const   { IM_ASSERT(it >= Data && it < DataEnd); const ptrdiff_t off = it - Data; return (int)off; }

};

// Helper: ImSpanAllocator<>

// Facilitate storing multiple chunks into a single large block (the "arena")

// - Usage: call Reserve() N times, allocate GetArenaSizeInBytes() worth, pass it to SetArenaBasePtr(), call GetSpan() N times to retrieve the aligned ranges.

template<int CHUNKS>

struct ImSpanAllocator

{

    char*   BasePtr;

    int     CurrOff;

    int     CurrIdx;

    int     Offsets[CHUNKS];

    int     Sizes[CHUNKS];

    ImSpanAllocator()                               { memset(this, 0, sizeof(*this)); }

    inline void  Reserve(int n, size_t sz, int a=4) { IM_ASSERT(n == CurrIdx && n < CHUNKS); CurrOff = IM_MEMALIGN(CurrOff, a); Offsets[n] = CurrOff; Sizes[n] = (int)sz; CurrIdx++; CurrOff += (int)sz; }

    inline int   GetArenaSizeInBytes()              { return CurrOff; }

    inline void  SetArenaBasePtr(void* base_ptr)    { BasePtr = (char*)base_ptr; }

    inline void* GetSpanPtrBegin(int n)             { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n]); }

    inline void* GetSpanPtrEnd(int n)               { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n] + Sizes[n]); }

    template<typename T>

    inline void  GetSpan(int n, ImSpan<T>* span)    { span->set((T*)GetSpanPtrBegin(n), (T*)GetSpanPtrEnd(n)); }

};

// Helper: ImPool<>

// Basic keyed storage for contiguous instances, slow/amortized insertion, O(1) indexable, O(Log N) queries by ID over a dense/hot buffer,

// Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object.

typedef int ImPoolIdx;

template<typename T>

struct ImPool

{

    ImVector<T>     Buf;        // Contiguous data

    ImGuiStorage    Map;        // ID->Index

    ImPoolIdx       FreeIdx;    // Next free idx to use

    ImPoolIdx       AliveCount; // Number of active/alive items (for display purpose)

    ImPool()    { FreeIdx = AliveCount = 0; }

    ~ImPool()   { Clear(); }

    T*          GetByKey(ImGuiID key)               { int idx = Map.GetInt(key, -1); return (idx != -1) ? &Buf[idx] : NULL; }

    T*          GetByIndex(ImPoolIdx n)             { return &Buf[n]; }

    ImPoolIdx   GetIndex(const T* p) const          { IM_ASSERT(p >= Buf.Data && p < Buf.Data + Buf.Size); return (ImPoolIdx)(p - Buf.Data); }

    T*          GetOrAddByKey(ImGuiID key)          { int* p_idx = Map.GetIntRef(key, -1); if (*p_idx != -1) return &Buf[*p_idx]; *p_idx = FreeIdx; return Add(); }

    bool        Contains(const T* p) const          { return (p >= Buf.Data && p < Buf.Data + Buf.Size); }

    void        Clear()                             { for (int n = 0; n < Map.Data.Size; n++) { int idx = Map.Data[n].val_i; if (idx != -1) Buf[idx].~T(); } Map.Clear(); Buf.clear(); FreeIdx = AliveCount = 0; }

    T*          Add()                               { int idx = FreeIdx; if (idx == Buf.Size) { Buf.resize(Buf.Size + 1); FreeIdx++; } else { FreeIdx = *(int*)&Buf[idx]; } IM_PLACEMENT_NEW(&Buf[idx]) T(); AliveCount++; return &Buf[idx]; }

    void        Remove(ImGuiID key, const T* p)     { Remove(key, GetIndex(p)); }

    void        Remove(ImGuiID key, ImPoolIdx idx)  { Buf[idx].~T(); *(int*)&Buf[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, -1); AliveCount--; }

    void        Reserve(int capacity)               { Buf.reserve(capacity); Map.Data.reserve(capacity); }

    // To iterate a ImPool: for (int n = 0; n < pool.GetMapSize(); n++) if (T* t = pool.TryGetMapData(n)) { ... }

    // Can be avoided if you know .Remove() has never been called on the pool, or AliveCount == GetMapSize()

    int         GetAliveCount() const               { return AliveCount; }      // Number of active/alive items in the pool (for display purpose)

    int         GetBufSize() const                  { return Buf.Size; }

    int         GetMapSize() const                  { return Map.Data.Size; }   // It is the map we need iterate to find valid items, since we don't have "alive" storage anywhere

    T*          TryGetMapData(ImPoolIdx n)          { int idx = Map.Data[n].val_i; if (idx == -1) return NULL; return GetByIndex(idx); }

};

// Helper: ImChunkStream<>

// Build and iterate a contiguous stream of variable-sized structures.

// This is used by Settings to store persistent data while reducing allocation count.

// We store the chunk size first, and align the final size on 4 bytes boundaries.

// The tedious/zealous amount of casting is to avoid -Wcast-align warnings.

template<typename T>

struct ImChunkStream

{

    ImVector<char>  Buf;

    void    clear()                     { Buf.clear(); }

    bool    empty() const               { return Buf.Size == 0; }

    int     size() const                { return Buf.Size; }

    T*      alloc_chunk(size_t sz)      { size_t HDR_SZ = 4; sz = IM_MEMALIGN(HDR_SZ + sz, 4u); int off = Buf.Size; Buf.resize(off + (int)sz); ((int*)(void*)(Buf.Data + off))[0] = (int)sz; return (T*)(void*)(Buf.Data + off + (int)HDR_SZ); }

    T*      begin()                     { size_t HDR_SZ = 4; if (!Buf.Data) return NULL; return (T*)(void*)(Buf.Data + HDR_SZ); }

    T*      next_chunk(T* p)            { size_t HDR_SZ = 4; IM_ASSERT(p >= begin() && p < end()); p = (T*)(void*)((char*)(void*)p + chunk_size(p)); if (p == (T*)(void*)((char*)end() + HDR_SZ)) return (T*)0; IM_ASSERT(p < end()); return p; }

    int     chunk_size(const T* p)      { return ((const int*)p)[-1]; }

    T*      end()                       { return (T*)(void*)(Buf.Data + Buf.Size); }

    int     offset_from_ptr(const T* p) { IM_ASSERT(p >= begin() && p < end()); const ptrdiff_t off = (const char*)p - Buf.Data; return (int)off; }

    T*      ptr_from_offset(int off)    { IM_ASSERT(off >= 4 && off < Buf.Size); return (T*)(void*)(Buf.Data + off); }

    void    swap(ImChunkStream<T>& rhs) { rhs.Buf.swap(Buf); }

};

// Helper: ImGuiTextIndex

// Maintain a line index for a text buffer. This is a strong candidate to be moved into the public API.

struct ImGuiTextIndex

{

    ImVector<int>   LineOffsets;

    int             EndOffset = 0;                          // Because we don't own text buffer we need to maintain EndOffset (may bake in LineOffsets?)

    void            clear()                                 { LineOffsets.clear(); EndOffset = 0; }

    int             size()                                  { return LineOffsets.Size; }

    const char*     get_line_begin(const char* base, int n) { return base + LineOffsets[n]; }

    const char*     get_line_end(const char* base, int n)   { return base + (n + 1 < LineOffsets.Size ? (LineOffsets[n + 1] - 1) : EndOffset); }

    void            append(const char* base, int old_size, int new_size);

};

// Helper: ImGuiStorage

IMGUI_API ImGuiStoragePair* ImLowerBound(ImGuiStoragePair* in_begin, ImGuiStoragePair* in_end, ImGuiID key);

//-----------------------------------------------------------------------------

// [SECTION] ImDrawList support

//-----------------------------------------------------------------------------

// ImDrawList: Helper function to calculate a circle's segment count given its radius and a "maximum error" value.

// Estimation of number of circle segment based on error is derived using method described in https://stackoverflow.com/a/2244088/15194693

// Number of segments (N) is calculated using equation:

//   N = ceil ( pi / acos(1 - error / r) )     where r > 0, error <= r

// Our equation is significantly simpler that one in the post thanks for choosing segment that is

// perpendicular to X axis. Follow steps in the article from this starting condition and you will

// will get this result.

//

// Rendering circles with an odd number of segments, while mathematically correct will produce

// asymmetrical results on the raster grid. Therefore we're rounding N to next even number (7->8, 8->8, 9->10 etc.)

#define IM_ROUNDUP_TO_EVEN(_V)                                  ((((_V) + 1) / 2) * 2)

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN                     4

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX                     512

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(_RAD,_MAXERROR)    ImClamp(IM_ROUNDUP_TO_EVEN((int)ImCeil(IM_PI / ImAcos(1 - ImMin((_MAXERROR), (_RAD)) / (_RAD)))), IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX)

// Raw equation from IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC rewritten for 'r' and 'error'.

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR)    ((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))))

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD)     ((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD))

// ImDrawList: Lookup table size for adaptive arc drawing, cover full circle.

#ifndef IM_DRAWLIST_ARCFAST_TABLE_SIZE

#define IM_DRAWLIST_ARCFAST_TABLE_SIZE                          48 // Number of samples in lookup table.

#endif

#define IM_DRAWLIST_ARCFAST_SAMPLE_MAX                          IM_DRAWLIST_ARCFAST_TABLE_SIZE // Sample index _PathArcToFastEx() for 360 angle.

// Data shared between all ImDrawList instances

// You may want to create your own instance of this if you want to use ImDrawList completely without ImGui. In that case, watch out for future changes to this structure.

struct IMGUI_API 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           FontScale;                  // Current/default font scale (== FontSize / Font->FontSize)

    float           CurveTessellationTol;       // Tessellation tolerance when using PathBezierCurveTo()

    float           CircleSegmentMaxError;      // Number of circle segments to use per pixel of radius for AddCircle() etc

    ImVec4          ClipRectFullscreen;         // Value for PushClipRectFullscreen()

    ImDrawListFlags InitialFlags;               // Initial flags at the beginning of the frame (it is possible to alter flags on a per-drawlist basis afterwards)

    // [Internal] Temp write buffer

    ImVector<ImVec2> TempBuffer;

    // [Internal] Lookup tables

    ImVec2          ArcFastVtx[IM_DRAWLIST_ARCFAST_TABLE_SIZE]; // Sample points on the quarter of the circle.

    float           ArcFastRadiusCutoff;                        // Cutoff radius after which arc drawing will fallback to slower PathArcTo()

    ImU8            CircleSegmentCounts[64];    // Precomputed segment count for given radius before we calculate it dynamically (to avoid calculation overhead)

    const ImVec4*   TexUvLines;                 // UV of anti-aliased lines in the atlas

    ImDrawListSharedData();

    void SetCircleTessellationMaxError(float max_error);

};

struct ImDrawDataBuilder

{

    ImVector<ImDrawList*>*  Layers[2];      // Pointers to global layers for: regular, tooltip. LayersP[0] is owned by DrawData.

    ImVector<ImDrawList*>   LayerData1;

    ImDrawDataBuilder()                     { memset(this, 0, sizeof(*this)); }

};

//-----------------------------------------------------------------------------

// [SECTION] Data types support

//-----------------------------------------------------------------------------

struct ImGuiDataVarInfo

{

    ImGuiDataType   Type;

    ImU32           Count;      // 1+

    ImU32           Offset;     // Offset in parent structure

    void* GetVarPtr(void* parent) const { return (void*)((unsigned char*)parent + Offset); }

};

struct ImGuiDataTypeStorage

{

    ImU8        Data[8];        // Opaque storage to fit any data up to ImGuiDataType_COUNT

};

// Type information associated to one ImGuiDataType. Retrieve with DataTypeGetInfo().

struct ImGuiDataTypeInfo

{

    size_t      Size;           // Size in bytes

    const char* Name;           // Short descriptive name for the type, for debugging

    const char* PrintFmt;       // Default printf format for the type

    const char* ScanFmt;        // Default scanf format for the type

};

// Extend ImGuiDataType_

enum ImGuiDataTypePrivate_

{

    ImGuiDataType_String = ImGuiDataType_COUNT + 1,

    ImGuiDataType_Pointer,

    ImGuiDataType_ID,

};

//-----------------------------------------------------------------------------

// [SECTION] Widgets support: flags, enums, data structures

//-----------------------------------------------------------------------------

// Extend ImGuiItemFlags

// - input: PushItemFlag() manipulates g.CurrentItemFlags, g.NextItemData.ItemFlags, ItemAdd() calls may add extra flags too.

// - output: stored in g.LastItemData.ItemFlags

enum ImGuiItemFlagsPrivate_

{

    // Controlled by user

    ImGuiItemFlags_Disabled                 = 1 << 10, // false     // Disable interactions (DOES NOT affect visuals. DO NOT mix direct use of this with BeginDisabled(). See BeginDisabled()/EndDisabled() for full disable feature, and github #211).

    ImGuiItemFlags_ReadOnly                 = 1 << 11, // false     // [ALPHA] Allow hovering interactions but underlying value is not changed.

    ImGuiItemFlags_MixedValue               = 1 << 12, // false     // [BETA] Represent a mixed/indeterminate value, generally multi-selection where values differ. Currently only supported by Checkbox() (later should support all sorts of widgets)

    ImGuiItemFlags_NoWindowHoverableCheck   = 1 << 13, // false     // Disable hoverable check in ItemHoverable()

    ImGuiItemFlags_AllowOverlap             = 1 << 14, // false     // Allow being overlapped by another widget. Not-hovered to Hovered transition deferred by a frame.

    ImGuiItemFlags_NoNavDisableMouseHover   = 1 << 15, // false     // Nav keyboard/gamepad mode doesn't disable hover highlight (behave as if NavHighlightItemUnderNav==false).

    ImGuiItemFlags_NoMarkEdited             = 1 << 16, // false     // Skip calling MarkItemEdited()

    // Controlled by widget code

    ImGuiItemFlags_Inputable                = 1 << 20, // false     // [WIP] Auto-activate input mode when tab focused. Currently only used and supported by a few items before it becomes a generic feature.

    ImGuiItemFlags_HasSelectionUserData     = 1 << 21, // false     // Set by SetNextItemSelectionUserData()

    ImGuiItemFlags_IsMultiSelect            = 1 << 22, // false     // Set by SetNextItemSelectionUserData()

    ImGuiItemFlags_Default_                 = ImGuiItemFlags_AutoClosePopups,    // Please don't change, use PushItemFlag() instead.

    // Obsolete

    //ImGuiItemFlags_SelectableDontClosePopup = !ImGuiItemFlags_AutoClosePopups, // Can't have a redirect as we inverted the behavior

};

// Status flags for an already submitted item

// - output: stored in g.LastItemData.StatusFlags

enum ImGuiItemStatusFlags_

{

    ImGuiItemStatusFlags_None               = 0,

    ImGuiItemStatusFlags_HoveredRect        = 1 << 0,   // Mouse position is within item rectangle (does NOT mean that the window is in correct z-order and can be hovered!, this is only one part of the most-common IsItemHovered test)

    ImGuiItemStatusFlags_HasDisplayRect     = 1 << 1,   // g.LastItemData.DisplayRect is valid

    ImGuiItemStatusFlags_Edited             = 1 << 2,   // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)

    ImGuiItemStatusFlags_ToggledSelection   = 1 << 3,   // Set when Selectable(), TreeNode() reports toggling a selection. We can't report "Selected", only state changes, in order to easily handle clipping with less issues.

    ImGuiItemStatusFlags_ToggledOpen        = 1 << 4,   // Set when TreeNode() reports toggling their open state.

    ImGuiItemStatusFlags_HasDeactivated     = 1 << 5,   // Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag.

    ImGuiItemStatusFlags_Deactivated        = 1 << 6,   // Only valid if ImGuiItemStatusFlags_HasDeactivated is set.

    ImGuiItemStatusFlags_HoveredWindow      = 1 << 7,   // Override the HoveredWindow test to allow cross-window hover testing.

    ImGuiItemStatusFlags_Visible            = 1 << 8,   // [WIP] Set when item is overlapping the current clipping rectangle (Used internally. Please don't use yet: API/system will change as we refactor Itemadd()).

    ImGuiItemStatusFlags_HasClipRect        = 1 << 9,   // g.LastItemData.ClipRect is valid.

    ImGuiItemStatusFlags_HasShortcut        = 1 << 10,  // g.LastItemData.Shortcut valid. Set by SetNextItemShortcut() -> ItemAdd().

    // Additional status + semantic for ImGuiTestEngine

#ifdef IMGUI_ENABLE_TEST_ENGINE

    ImGuiItemStatusFlags_Openable           = 1 << 20,  // Item is an openable (e.g. TreeNode)

    ImGuiItemStatusFlags_Opened             = 1 << 21,  // Opened status

    ImGuiItemStatusFlags_Checkable          = 1 << 22,  // Item is a checkable (e.g. CheckBox, MenuItem)

    ImGuiItemStatusFlags_Checked            = 1 << 23,  // Checked status

    ImGuiItemStatusFlags_Inputable          = 1 << 24,  // Item is a text-inputable (e.g. InputText, SliderXXX, DragXXX)

#endif

};

// Extend ImGuiHoveredFlags_