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

#define _CRT_SECURE_NO_WARNINGS

#endif

#include "imgui.h"

#define IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_PLACEMENT_NEW

#include "imgui_internal.h"

#include <ctype.h> // toupper, isprint

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

#include <stdio.h> // vsnprintf, sscanf, printf

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

#if defined(_MSC_VER) && _MSC_VER <= 1500 // MSVC 2008 or earlier

#include <stddef.h> // intptr_t

#else

#include <stdint.h> // intptr_t

#endif

#ifdef _MSC_VER

#pragma warning(disable : 4127) // condition expression is constant

#pragma warning(disable : 4505) // unreferenced local function has been removed (stb stuff)

#pragma warning(disable : 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen

#endif

#ifdef __clang__

#pragma clang diagnostic ignored "-Wold-style-cast" // warning : use of old-style cast // yes, they are more terse.

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

#pragma clang diagnostic ignored "-Wformat-nonliteral" // warning : format string is not a string literal // passing non-literal to vsnformat(). yes, user passing incorrect format strings can crash the code.

#pragma clang diagnostic ignored "-Wexit-time-destructors" // warning : declaration requires an exit-time destructor // exit-time destruction order is undefined. if MemFree() leads to users code that has been disabled before exit it might cause problems. ImGui coding style welcomes static/globals.

#pragma clang diagnostic ignored "-Wglobal-constructors" // warning : declaration requires a global destructor // similar to above, not sure what the exact difference it.

#pragma clang diagnostic ignored "-Wsign-conversion" // warning : implicit conversion changes signedness //

#pragma clang diagnostic ignored "-Wformat-pedantic" // warning : format specifies type 'void *' but the argument has type 'xxxx *' // unreasonable, would lead to casting every %p arg to void*. probably enabled by -pedantic.

#pragma clang diagnostic ignored "-Wint-to-void-pointer-cast" // warning : cast to 'void *' from smaller integer type 'int' //

#elif defined(__GNUC__)

#pragma GCC diagnostic ignored "-Wunused-function" // warning: 'xxxx' defined but not used

#pragma GCC diagnostic ignored "-Wint-to-pointer-cast" // warning: cast to pointer from integer of different size

#pragma GCC diagnostic ignored "-Wformat" // warning: format '%p' expects argument of type 'void*', but argument 6 has type 'ImGuiWindow*'

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

#pragma GCC diagnostic ignored "-Wconversion" // warning: conversion to 'xxxx' from 'xxxx' may alter its value

#pragma GCC diagnostic ignored "-Wcast-qual" // warning: cast from type 'xxxx' to type 'xxxx' casts away qualifiers

#endif

static void LogRenderedText(const ImVec2& ref_pos, const char* text, const char* text_end = nullptr);

static void PushMultiItemsWidths(int components, float w_full = 0.0f);

static float GetDraggedColumnOffset(int column_index);

static bool IsKeyPressedMap(ImGuiKey key, bool repeat = true);

static ImFont* GetDefaultFont();

static void SetCurrentFont(ImFont* font);

static void SetCurrentWindow(ImGuiWindow* window);

static void SetWindowScrollY(ImGuiWindow* window, float new_scroll_y);

static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond);

static void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiSetCond cond);

static void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiSetCond cond);

static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs);

static ImGuiWindow* CreateNewWindow(const char* name, ImVec2 size, ImGuiWindowFlags flags);

static inline bool IsWindowContentHoverable(ImGuiWindow* window);

static void ClearSetNextWindowData();

static void CheckStacksSize(ImGuiWindow* window, bool write);

static void Scrollbar(ImGuiWindow* window, bool horizontal);

static void AddDrawListToRenderList(ImVector<ImDrawList*>& out_render_list, ImDrawList* draw_list);

static void AddWindowToRenderList(ImVector<ImDrawList*>& out_render_list, ImGuiWindow* window);

static void AddWindowToSortedBuffer(ImVector<ImGuiWindow*>& out_sorted_windows, ImGuiWindow* window);

static ImGuiIniData* FindWindowSettings(const char* name);

static ImGuiIniData* AddWindowSettings(const char* name);

static void LoadIniSettingsFromDisk(const char* ini_filename);

static void SaveIniSettingsToDisk(const char* ini_filename);

static void MarkIniSettingsDirty();

static void PushColumnClipRect(int column_index = -1);

static ImRect GetVisibleRect();

static bool BeginPopupEx(const char* str_id, ImGuiWindowFlags extra_flags);

static void CloseInactivePopups();

static void ClosePopupToLevel(int remaining);

static void ClosePopup(ImGuiID id);

static bool IsPopupOpen(ImGuiID id);

static ImGuiWindow* GetFrontMostModalRootWindow();

static ImVec2 FindBestPopupWindowPos(const ImVec2& base_pos, const ImVec2& size, int* last_dir, const ImRect& rect_to_avoid);

static bool InputTextFilterCharacter(unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data);

static int InputTextCalcTextLenAndLineCount(const char* text_begin, const char** out_text_end);

static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining = nullptr, ImVec2* out_offset = nullptr, bool stop_on_new_line = false);

static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, const char* display_format, char* buf, int buf_size);

static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, int decimal_precision, char* buf, int buf_size);

static void DataTypeApplyOp(ImGuiDataType data_type, int op, void* value1, const void* value2);

static bool DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* data_ptr, const char* scalar_format);

static const char* GetClipboardTextFn_DefaultImpl(void* user_data);

static void SetClipboardTextFn_DefaultImpl(void* user_data, const char* text);

static void ImeSetInputScreenPosFn_DefaultImpl(int x, int y);

static ImFontAtlas GImDefaultFontAtlas;

#ifndef GImGui

static ImGuiContext GImDefaultContext;

ImGuiContext* GImGui = &GImDefaultContext;

#endif

ImGuiStyle::ImGuiStyle()

}

ImGuiIO::ImGuiIO()

}

void ImGuiIO::AddInputCharacter(ImWchar c)

}

void ImGuiIO::AddInputCharactersUTF8(const char* utf8_chars)

}

#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

#ifdef _WIN32

#define IM_NEWLINE "\r\n"

#else

#define IM_NEWLINE "\n"

#endif

bool ImIsPointInTriangle(const ImVec2& p, const ImVec2& a, const ImVec2& b, const ImVec2& c)

}

int ImStricmp(const char* str1, const char* str2)

}

int ImStrnicmp(const char* str1, const char* str2, int count)

}

void ImStrncpy(char* dst, const char* src, int count)

}

char* ImStrdup(const char* str)

{

size_t len = strlen(str) + 1;

void* buff = ImGui::MemAlloc(len);

return (char*)memcpy(buff, (const void*)str, len);

}

int ImStrlenW(const ImWchar* str)

}

const ImWchar* ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin) // find beginning-of-line

{

while (buf_mid_line > buf_begin && buf_mid_line[-1] != '\n')

buf_mid_line--;

return buf_mid_line;

}

const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end)

{

if (!needle_end)

needle_end = needle + strlen(needle);

const char un0 = (char)toupper(*needle);

while ((!haystack_end && *haystack) || (haystack_end && haystack < haystack_end)) {

if (toupper(*haystack) == un0) {

const char* b = needle + 1;

for (const char* a = haystack + 1; b < needle_end; a++, b++)

if (toupper(*a) != toupper(*b))

break;

if (b == needle_end)

return haystack;

}

haystack++;

}

return nullptr;

}

int ImFormatString(char* buf, int buf_size, const char* fmt, ...)

}

int ImFormatStringV(char* buf, int buf_size, const char* fmt, va_list args)

}