// dear imgui, v1.91.5

// (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 "-Wold-style-cast"                 // warning: use of old-style cast

#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"  // warning: zero as null pointer constant

#pragma clang diagnostic ignored "-Wdouble-promotion"               // warning: implicit conversion from 'float' to 'double' when passing argument to function

#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

#pragma clang diagnostic ignored "-Wnontrivial-memaccess"           // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type

#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 ImGuiLogFlags;              // -> enum ImGuiLogFlags_           // Flags: for LogBegin() text capturing function

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

// Hint for branch prediction

#if (defined(__cplusplus) && (__cplusplus >= 202002L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L))

#define IM_LIKELY   [[likely]]

#define IM_UNLIKELY [[unlikely]]

#else

#define IM_LIKELY

#define IM_UNLIKELY

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