pwmgr

// (headers)

// Help:

// - See links below.

// - Call and read ImGui::ShowDemoWindow() in imgui_demo.cpp. All applications in examples/ are doing that.

// - Read top of imgui.cpp for more details, links and comments.

// Resources:

// For first-time users having issues compiling/linking/running/loading fonts:

// please post in https://github.com/ocornut/imgui/discussions if you cannot find a solution in resources above.

// Library Version

// (Integer encoded as XYYZZ for use in #if preprocessor conditionals, e.g. '#if IMGUI_VERSION_NUM >= 12345')

#define IMGUI_HAS_TABLE

/*

// [SECTION] Dear ImGui end-user API functions

// [SECTION] Flags & Enumerations

// [SECTION] Tables API flags and structures (ImGuiTableFlags, ImGuiTableColumnFlags, ImGuiTableRowFlags, ImGuiTableBgTarget, ImGuiTableSortSpecs, ImGuiTableColumnSortSpecs)

// [SECTION] ImGuiStyle

// [SECTION] ImGuiIO

// [SECTION] Misc data structures (ImGuiInputTextCallbackData, ImGuiSizeCallbackData, ImGuiPayload)

// [SECTION] Helpers (ImGuiOnceUponAFrame, ImGuiTextFilter, ImGuiTextBuffer, ImGuiStorage, ImGuiListClipper, Math Operators, ImColor)

// [SECTION] Drawing API (ImDrawCallback, ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListSplitter, ImDrawFlags, ImDrawListFlags, ImDrawList, ImDrawData)

// [SECTION] Font API (ImFontConfig, ImFontGlyph, ImFontGlyphRangesBuilder, ImFontAtlasFlags, ImFontAtlas, ImFont)

// [SECTION] Viewports (ImGuiViewportFlags, ImGuiViewport)

// [SECTION] Obsolete functions and types

*/

#endif

#define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR)))) // Size of a static C-style array. Don't use on pointers!

#define IM_UNUSED(_VAR) ((void)(_VAR)) // Used to silence "unused variable warnings". Often useful as asserts may be stripped out from final builds.

#define IMGUI_CHECKVERSION() ImGui::DebugCheckVersionAndDataLayout(IMGUI_VERSION, sizeof(ImGuiIO), sizeof(ImGuiStyle), sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert), sizeof(ImDrawIdx))

// Helper Macros - IM_FMTARGS, IM_FMTLIST: Apply printf-style warnings to our formatting functions.

#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

#pragma clang diagnostic ignored "-Wreserved-identifier" // warning: identifier '_Xxx' is reserved because it starts with '_' followed by a capital letter

#elif defined(__GNUC__)

#pragma GCC diagnostic push

#endif

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

// [SECTION] Forward declarations and basic types

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

// Forward declarations

struct ImDrawChannel; // Temporary storage to output draw commands out of order, used by ImDrawListSplitter and ImDrawList::ChannelsSplit()

struct ImDrawCmd; // A single draw command within a parent ImDrawList (generally maps to 1 GPU draw call, unless it is a callback)

struct ImFontGlyphRangesBuilder; // Helper to build glyph ranges from text/string data

struct ImColor; // Helper functions to create a color that can be converted to either u32 or float4 (*OBSOLETE* please avoid using)

struct ImGuiContext; // Dear ImGui context (opaque structure, unless including imgui_internal.h)

struct ImGuiInputTextCallbackData; // Shared state of InputText() when using custom ImGuiInputTextCallback (rare/advanced use)

struct ImGuiKeyData; // Storage for ImGuiIO and IsKeyDown(), IsKeyPressed() etc functions.

struct ImGuiListClipper; // Helper to manually clip large list of items

struct ImGuiOnceUponAFrame; // Helper for running a block of code not more than once a frame

struct ImGuiPayload; // User data payload for drag and drop operations

struct ImGuiSizeCallbackData; // Callback data when using SetNextWindowSizeConstraints() (rare/advanced use)

struct ImGuiStyle; // Runtime data for styling/colors

struct ImGuiTableSortSpecs; // Sorting specifications for a table (often handling sort specs for a single column, occasionally more)

struct ImGuiTableColumnSortSpecs; // Sorting specification for one column of a table

// Enumerations

// - We don't use strongly typed enums much because they add constraints (can't extend in private code, can't store typed in bit fields, extra casting on iteration)

// - Tip: Use your programming IDE navigation facilities on the names in the _central column_ below to find the actual flags/enum lists!

enum ImGuiKey : int; // -> enum ImGuiKey // Enum: A key identifier (ImGuiKey_XXX or ImGuiMod_XXX value)

enum ImGuiMouseSource : int; // -> enum ImGuiMouseSource // Enum; A mouse input source identifier (Mouse, TouchScreen, Pen)

typedef int ImGuiCol; // -> enum ImGuiCol_ // Enum: A color identifier for styling

typedef int ImGuiCond; // -> enum ImGuiCond_ // Enum: A condition for many Set*() functions

typedef int ImGuiDataType; // -> enum ImGuiDataType_ // Enum: A primary data type

typedef int ImGuiMouseButton; // -> enum ImGuiMouseButton_ // Enum: A mouse button identifier (0=left, 1=right, 2=middle)

typedef int ImGuiMouseCursor; // -> enum ImGuiMouseCursor_ // Enum: A mouse cursor shape

typedef int ImGuiStyleVar; // -> enum ImGuiStyleVar_ // Enum: A variable identifier for styling

typedef int ImGuiTableBgTarget; // -> enum ImGuiTableBgTarget_ // Enum: A color target for TableSetBgColor()

// Flags (declared as int to allow using as flags without overhead, and to not pollute the top of this file)

// - Tip: Use your programming IDE navigation facilities on the names in the _central column_ below to find the actual flags/enum lists!

typedef int ImDrawFlags; // -> enum ImDrawFlags_ // Flags: for ImDrawList functions

typedef int ImDrawListFlags; // -> enum ImDrawListFlags_ // Flags: for ImDrawList instance

typedef int ImFontAtlasFlags; // -> enum ImFontAtlasFlags_ // Flags: for ImFontAtlas build

typedef int ImGuiDragDropFlags; // -> enum ImGuiDragDropFlags_ // Flags: for BeginDragDropSource(), AcceptDragDropPayload()

typedef int ImGuiFocusedFlags; // -> enum ImGuiFocusedFlags_ // Flags: for IsWindowFocused()

typedef int ImGuiHoveredFlags; // -> enum ImGuiHoveredFlags_ // Flags: for IsItemHovered(), IsWindowHovered() etc.

typedef int ImGuiInputTextFlags; // -> enum ImGuiInputTextFlags_ // Flags: for InputText(), InputTextMultiline()

typedef int ImGuiKeyChord; // -> ImGuiKey | ImGuiMod_XXX // Flags: for IsKeyChordPressed(), Shortcut() etc. an ImGuiKey optionally OR-ed with one or more ImGuiMod_XXX values.

typedef int ImGuiPopupFlags; // -> enum ImGuiPopupFlags_ // Flags: for OpenPopup*(), BeginPopupContext*(), IsPopupOpen()

typedef int ImGuiSelectableFlags; // -> enum ImGuiSelectableFlags_ // Flags: for Selectable()

typedef int ImGuiSliderFlags; // -> enum ImGuiSliderFlags_ // Flags: for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc.

typedef int ImGuiTabBarFlags; // -> enum ImGuiTabBarFlags_ // Flags: for BeginTabBar()

// ImTexture: user data for renderer backend to identify a texture [Compile-time configurable type]

// - To use something else than an opaque void* pointer: override with e.g. '#define ImTextureID MyTextureType*' in your imconfig.h file.

// - This can be whatever to you want it to be! read the FAQ about ImTextureID for details.

#ifndef ImTextureID

#endif

// ImDrawIdx: vertex index. [Compile-time configurable type]

typedef unsigned short ImDrawIdx; // Default: 16-bit (for maximum compatibility with renderer backends)

#endif

// Character types

// (we generally use UTF-8 encoded string in the API. This is storage specifically for a decoded character used for keyboard input and display)

typedef unsigned int ImWchar32; // A single decoded U32 character/code point. We encode them as multi bytes UTF-8 when used in strings.

typedef ImWchar16 ImWchar;

#endif

// Callback and functions types

typedef int (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData* data); // Callback function for ImGui::InputText()

typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data); // Callback function for ImGui::SetNextWindowSizeConstraints()

typedef void (*ImGuiMemFreeFunc)(void* ptr, void* user_data); // Function signature for ImGui::SetAllocatorFunctions()

// ImVec2: 2D vector used to store positions, sizes etc. [Compile-time configurable type]

IM_MSVC_RUNTIME_CHECKS_OFF

struct ImVec2

{

IMGUI_API void SetCurrentContext(ImGuiContext* ctx);

// Main

IMGUI_API ImGuiStyle& GetStyle(); // access the Style structure (colors, sizes). Always use PushStyleColor(), PushStyleVar() to modify style mid-frame!

IMGUI_API void NewFrame(); // start a new Dear ImGui frame, you can submit any command from this point until Render()/EndFrame().

IMGUI_API void EndFrame(); // ends the Dear ImGui frame. automatically called by Render(). If you don't need to render data (skipping rendering) you may call EndFrame() without Render()... but you'll have wasted CPU already! If you don't need to render, better to not create any windows and not call NewFrame() at all!

// Child Windows

// - Use child windows to begin into a self-contained independent scrolling/clipping regions within a host window. Child windows can embed their own child.

// - Before 1.90 (November 2023), the "ImGuiChildFlags child_flags = 0" parameter was "bool border = false".

// Consider updating your old code:

// BeginChild("Name", size, false) -> Begin("Name", size, 0); or Begin("Name", size, ImGuiChildFlags_None);

// - Manual sizing (each axis can use a different setting e.g. ImVec2(0.0f, 400.0f)):

// == 0.0f: use remaining parent window size for this axis.

// > 0.0f: use specified size for this axis.

IMGUI_API bool IsWindowFocused(ImGuiFocusedFlags flags=0); // is current window focused? or its root/child, depending on flags. see flags for options.

IMGUI_API bool IsWindowHovered(ImGuiHoveredFlags flags=0); // is current window hovered and hoverable (e.g. not blocked by a popup/modal)? See ImGuiHoveredFlags_ for options. IMPORTANT: If you are trying to check whether your mouse should be dispatched to Dear ImGui or to your underlying app, you should not use this function! Use the 'io.WantCaptureMouse' boolean for that! Refer to FAQ entry "How can I tell whether to dispatch mouse/keyboard to Dear ImGui or my application?" for details.

IMGUI_API ImDrawList* GetWindowDrawList(); // get draw list associated to the current window, to append your own drawing primitives

// Window manipulation

// - Prefer using SetNextXXX functions (before Begin) rather that SetXXX functions (after Begin).

IMGUI_API void SetWindowCollapsed(const char* name, bool collapsed, ImGuiCond cond = 0); // set named window collapsed state

IMGUI_API void SetWindowFocus(const char* name); // set named window to be focused / top-most. use NULL to remove focus.

// Windows Scrolling

// - Any change of Scroll will be applied at the beginning of next frame in the first call to Begin().

// - You may instead use SetNextWindowScroll() prior to calling Begin() to avoid this delay, as an alternative to using SetScrollX()/SetScrollY().

IMGUI_API void PushStyleColor(ImGuiCol idx, ImU32 col); // modify a style color. always use this if you modify the style after NewFrame().

IMGUI_API void PushStyleColor(ImGuiCol idx, const ImVec4& col);

IMGUI_API void PopStyleColor(int count = 1);

IMGUI_API void PopStyleVar(int count = 1);

// Parameters stacks (current window)

IMGUI_API void PushItemWidth(float item_width); // push width of items for common large "item+label" widgets. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side).

// - Use the ShowStyleEditor() function to interactively see/edit the colors.

IMGUI_API ImFont* GetFont(); // get current font

IMGUI_API float GetFontSize(); // get current font size (= height in pixels) of current font with current scale applied

IMGUI_API ImU32 GetColorU32(ImGuiCol idx, float alpha_mul = 1.0f); // retrieve given style color with style alpha applied and optional extra alpha multiplier, packed as a 32-bit value suitable for ImDrawList

IMGUI_API ImU32 GetColorU32(const ImVec4& col); // retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList

IMGUI_API const ImVec4& GetStyleColorVec4(ImGuiCol idx); // retrieve style color as stored in ImGuiStyle structure. use to feed back into PushStyleColor(), otherwise use GetColorU32() to get style color with style alpha baked in.

// Layout cursor positioning

// - By "cursor" we mean the current output position.

// - The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down.

// - You can call SameLine() between widgets to undo the last carriage return and output at the right of the preceding widget.

// - Attention! We currently have inconsistencies between window-local and absolute positions we will aim to fix with future API:

// - Absolute coordinate: GetCursorScreenPos(), SetCursorScreenPos(), all ImDrawList:: functions. -> this is the preferred way forward.

IMGUI_API float GetCursorPosX(); // [window-local] "

IMGUI_API float GetCursorPosY(); // [window-local] "

IMGUI_API void SetCursorPos(const ImVec2& local_pos); // [window-local] "

IMGUI_API void SetCursorPosX(float local_x); // [window-local] "

IMGUI_API void SetCursorPosY(float local_y); // [window-local] "

// Other layout functions

IMGUI_API void Separator(); // separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.

IMGUI_API ImGuiID GetID(const char* str_id); // calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself

IMGUI_API ImGuiID GetID(const char* str_id_begin, const char* str_id_end);

IMGUI_API ImGuiID GetID(const void* ptr_id);

// Widgets: Text

IMGUI_API void TextUnformatted(const char* text, const char* text_end = NULL); // raw text without formatting. Roughly equivalent to Text("%s", text) but: A) doesn't require null terminated string if 'text_end' is specified, B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text.

IMGUI_API bool RadioButton(const char* label, int* v, int v_button); // shortcut to handle the above pattern when value is an integer

IMGUI_API void ProgressBar(float fraction, const ImVec2& size_arg = ImVec2(-FLT_MIN, 0), const char* overlay = NULL);

IMGUI_API void Bullet(); // draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses

// Widgets: Images

// - Read about ImTextureID here: https://github.com/ocornut/imgui/wiki/Image-Loading-and-Displaying-Examples

// the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x

// - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.

// - Format string may also be set to NULL or use the default format ("%f" or "%d").

// - Use v_min < v_max to clamp edits to given limits. Note that CTRL+Click manual input can override those limits if ImGuiSliderFlags_AlwaysClamp is not used.

// - Use v_max = FLT_MAX / INT_MAX etc to avoid clamping to a maximum, same with v_min = -FLT_MAX / INT_MIN to avoid clamping to a minimum.

// - We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.

IMGUI_API bool CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags = 0); // if returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().

IMGUI_API bool CollapsingHeader(const char* label, bool* p_visible, ImGuiTreeNodeFlags flags = 0); // when 'p_visible != NULL': if '*p_visible==true' display an additional small close button on upper right of the header which will set the bool to false when clicked, if '*p_visible==false' don't display the header.

IMGUI_API void SetNextItemOpen(bool is_open, ImGuiCond cond = 0); // set next TreeNode/CollapsingHeader open state.

// Widgets: Selectables

// - A selectable highlights when hovered, and can display another color when selected.

IMGUI_API bool Selectable(const char* label, bool selected = false, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0, 0)); // "bool selected" carry the selection state (read-only). Selectable() is clicked is returns true so you can modify your selection state. size.x==0.0: use remaining width, size.x>0.0: specify width. size.y==0.0: use label height, size.y>0.0: specify height

IMGUI_API bool Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0, 0)); // "bool* p_selected" point to the selection state (read-write), as a convenient helper.

// Widgets: List Boxes

// - This is essentially a thin wrapper to using BeginChild/EndChild with the ImGuiChildFlags_FrameStyle flag for stylistic changes + displaying a label.

// - You can submit contents and manage your selection state however you want it, by creating e.g. Selectable() or any other items.

// Tooltips

// - Tooltips are windows following the mouse. They do not take focus away.

IMGUI_API bool BeginTooltip(); // begin/append a tooltip window.

IMGUI_API void EndTooltip(); // only call EndTooltip() if BeginTooltip()/BeginItemTooltip() returns true!

IMGUI_API void SetTooltip(const char* fmt, ...) IM_FMTARGS(1); // set a text-only tooltip. Often used after a ImGui::IsItemHovered() check. Override any previous call to SetTooltip().

// - SetItemTooltip() is a shortcut for the 'if (IsItemHovered(ImGuiHoveredFlags_ForTooltip)) { SetTooltip(...); }' idiom.

// - Where 'ImGuiHoveredFlags_ForTooltip' itself is a shortcut to use 'style.HoverFlagsForTooltipMouse' or 'style.HoverFlagsForTooltipNav' depending on active input type. For mouse it defaults to 'ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayShort'.

IMGUI_API bool BeginItemTooltip(); // begin/append a tooltip window if preceding item was hovered.

IMGUI_API void SetItemTooltipV(const char* fmt, va_list args) IM_FMTLIST(1);

// Popups, Modals

// - TableNextColumn() -> Text("Hello 0") -> TableNextColumn() -> Text("Hello 1") // OK: TableNextColumn() automatically gets to next row!

// - TableNextRow() -> Text("Hello 0") // Not OK! Missing TableSetColumnIndex() or TableNextColumn()! Text will not appear!

// - 5. Call EndTable()

IMGUI_API void EndTable(); // only call EndTable() if BeginTable() returns true!

IMGUI_API void TableNextRow(ImGuiTableRowFlags row_flags = 0, float min_row_height = 0.0f); // append into the first cell of a new row.

IMGUI_API bool TableNextColumn(); // append into the next column (or first column of next row if currently in last column). Return true when column is visible.

IMGUI_API const char* TableGetColumnName(int column_n = -1); // return "" if column didn't have a name declared by TableSetupColumn(). Pass -1 to use current column.

IMGUI_API ImGuiTableColumnFlags TableGetColumnFlags(int column_n = -1); // return column flags so you can query their Enabled/Visible/Sorted/Hovered status flags. Pass -1 to use current column.

IMGUI_API void TableSetColumnEnabled(int column_n, bool v);// change user accessible enabled/disabled state of a column. Set to false to hide the column. User can use the context menu to change this themselves (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody)

IMGUI_API void TableSetBgColor(ImGuiTableBgTarget target, ImU32 color, int column_n = -1); // change the color of a cell, row, or column. See ImGuiTableBgTarget_ flags for details.

// Legacy Columns API (prefer using Tables!)

// - You can also use SameLine(pos_x) to mimic simplified columns.

IMGUI_API void NextColumn(); // next column, defaults to current row or next row if the current row is finished

IMGUI_API int GetColumnIndex(); // get current column index

IMGUI_API float GetColumnWidth(int column_index = -1); // get column width (in pixels). pass -1 to use current column

// Disabling [BETA API]

// - Disable all user interactions and dim items visuals (applying style.DisabledAlpha over current colors)

// - Those can be nested but it cannot be used to enable an already disabled section (a single BeginDisabled(true) in the stack is enough to keep everything disabled)

IMGUI_API void BeginDisabled(bool disabled = true);

IMGUI_API void EndDisabled();

IMGUI_API void PopClipRect();

// Focus, Activation

IMGUI_API void SetKeyboardFocusHere(int offset = 0); // focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget.

// Overlapping mode

IMGUI_API void SetNextItemAllowOverlap(); // allow next item to be overlapped by a subsequent item. Useful with invisible buttons, selectable, treenode covering an area where subsequent items may need to be added. Note that both Selectable() and TreeNode() have dedicated flags doing this.

// Inputs Utilities: Keyboard/Mouse/Gamepad

// - the ImGuiKey enum contains all possible keyboard, mouse and gamepad inputs (e.g. ImGuiKey_A, ImGuiKey_MouseLeft, ImGuiKey_GamepadDpadUp...).

IMGUI_API bool IsKeyDown(ImGuiKey key); // is key being held.

IMGUI_API bool IsKeyPressed(ImGuiKey key, bool repeat = true); // was key pressed (went from !Down to Down)? if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate

IMGUI_API bool IsKeyReleased(ImGuiKey key); // was key released (went from Down to !Down)?

IMGUI_API const char* GetKeyName(ImGuiKey key); // [DEBUG] returns English name of the key. Those names a provided for debugging purpose and are not meant to be saved persistently not compared.

IMGUI_API void SetNextFrameWantCaptureKeyboard(bool want_capture_keyboard); // Override io.WantCaptureKeyboard flag next frame (said flag is left for your application to handle, typically when true it instructs your app to ignore inputs). e.g. force capture keyboard when your widget is being hovered. This is equivalent to setting "io.WantCaptureKeyboard = want_capture_keyboard"; after the next NewFrame() call.

// - To refer to a mouse button, you may use named enums in your code e.g. ImGuiMouseButton_Left, ImGuiMouseButton_Right.

// - You can also use regular integer: it is forever guaranteed that 0=Left, 1=Right, 2=Middle.

// - Dragging operations are only reported after mouse has moved a certain distance away from the initial clicking position (see 'lock_threshold' and 'io.MouseDraggingThreshold')

IMGUI_API bool IsAnyMouseDown(); // [WILL OBSOLETE] is any mouse button held? This was designed for backends, but prefer having backend maintain a mask of held mouse buttons, because upcoming input queue system will make this invalid.

IMGUI_API ImVec2 GetMousePos(); // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls

IMGUI_API ImVec2 GetMousePosOnOpeningCurrentPopup(); // retrieve mouse position at the time of opening popup we have BeginPopup() into (helper to avoid user backing that value themselves)

IMGUI_API void ResetMouseDragDelta(ImGuiMouseButton button = 0); //

IMGUI_API ImGuiMouseCursor GetMouseCursor(); // get desired mouse cursor shape. Important: reset in ImGui::NewFrame(), this is updated during the frame. valid before Render(). If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you

IMGUI_API void SetMouseCursor(ImGuiMouseCursor cursor_type); // set desired mouse cursor shape

// - Your main debugging friend is the ShowMetricsWindow() function, which is also accessible from Demo->Tools->Metrics Debugger

IMGUI_API void DebugTextEncoding(const char* text);

IMGUI_API void DebugFlashStyleColor(ImGuiCol idx);

IMGUI_API bool DebugCheckVersionAndDataLayout(const char* version_str, size_t sz_io, size_t sz_style, size_t sz_vec2, size_t sz_vec4, size_t sz_drawvert, size_t sz_drawidx); // This is called by IMGUI_CHECKVERSION() macro.

// Memory Allocators

// - Those functions are not reliant on the current context.

ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13, // Disable bringing window to front when taking focus (e.g. clicking on it or programmatically giving it focus)

ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14, // Always show vertical scrollbar (even if ContentSize.y < Size.y)

ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15, // Always show horizontal scrollbar (even if ContentSize.x < Size.x)

ImGuiWindowFlags_UnsavedDocument = 1 << 18, // Display a dot next to the title. When used in a tab/docking context, tab is selected when clicking the X + closure is not assumed (will wait for user to stop submitting the tab). Otherwise closure is assumed when pressing the X, so if you keep submitting the tab may reappear at end of tab bar.

ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,

ImGuiWindowFlags_NoDecoration = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse,

ImGuiWindowFlags_NoInputs = ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,

// [Internal]

ImGuiWindowFlags_ChildWindow = 1 << 24, // Don't use! For internal use by BeginChild()

ImGuiWindowFlags_Tooltip = 1 << 25, // Don't use! For internal use by BeginTooltip()

ImGuiWindowFlags_Popup = 1 << 26, // Don't use! For internal use by BeginPopup()

// Obsolete names

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

#endif

};

// Flags for ImGui::BeginChild()

// About using AutoResizeX/AutoResizeY flags:

// - May be combined with SetNextWindowSizeConstraints() to set a min/max size for each axis (see "Demo->Child->Auto-resize with Constraints").

// - Size measurement for a given axis is only performed when the child window is within visible boundaries, or is just appearing.

enum ImGuiChildFlags_

{

ImGuiChildFlags_None = 0,

ImGuiChildFlags_AlwaysUseWindowPadding = 1 << 1, // Pad with style.WindowPadding even if no border are drawn (no padding by default for non-bordered child windows because it makes more sense)

ImGuiChildFlags_ResizeX = 1 << 2, // Allow resize from right border (layout direction). Enable .ini saving (unless ImGuiWindowFlags_NoSavedSettings passed to window flags)

ImGuiChildFlags_ResizeY = 1 << 3, // Allow resize from bottom border (layout direction). "

ImGuiChildFlags_AutoResizeY = 1 << 5, // Enable auto-resizing height. Read "IMPORTANT: Size measurement" details above.

ImGuiChildFlags_AlwaysAutoResize = 1 << 6, // Combined with AutoResizeX/AutoResizeY. Always measure size even when child is hidden, always return true, always disable clipping optimization! NOT RECOMMENDED.

ImGuiChildFlags_FrameStyle = 1 << 7, // Style the child window like a framed item: use FrameBg, FrameRounding, FrameBorderSize, FramePadding instead of ChildBg, ChildRounding, ChildBorderSize, WindowPadding.

};

// Flags for ImGui::InputText()

// (Those are per-item flags. There are shared flags in ImGuiIO: io.ConfigInputTextCursorBlink and io.ConfigInputTextEnterKeepActive)

enum ImGuiInputTextFlags_

{

ImGuiInputTextFlags_None = 0,

ImGuiInputTextFlags_CharsDecimal = 1 << 0, // Allow 0123456789.+-*/

ImGuiInputTextFlags_CharsHexadecimal = 1 << 1, // Allow 0123456789ABCDEFabcdef

ImGuiInputTextFlags_NoUndoRedo = 1 << 16, // Disable undo/redo. Note that input text owns the text data while active, if you want to provide your own undo/redo stack you need e.g. to call ClearActiveID().

// Obsolete names

//ImGuiInputTextFlags_AlwaysInsertMode = ImGuiInputTextFlags_AlwaysOverwrite // [renamed in 1.82] name was not matching behavior

ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3, // Don't do a TreePush() when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack

ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4, // Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes)

ImGuiTreeNodeFlags_DefaultOpen = 1 << 5, // Default node to be open

ImGuiTreeNodeFlags_Leaf = 1 << 8, // No collapsing, no arrow (use as a convenience for leaf nodes).

ImGuiTreeNodeFlags_Bullet = 1 << 9, // Display a bullet instead of arrow. IMPORTANT: node can still be marked open/close if you don't set the _Leaf flag!

ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog,

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

enum ImGuiSelectableFlags_

{

ImGuiSelectableFlags_None = 0,

ImGuiSelectableFlags_SpanAllColumns = 1 << 1, // Frame will span all columns of its container table (text will still fit in current column)

ImGuiSelectableFlags_AllowDoubleClick = 1 << 2, // Generate press events on double clicks too

ImGuiSelectableFlags_Disabled = 1 << 3, // Cannot be selected, display grayed out text

ImGuiSelectableFlags_AllowOverlap = 1 << 4, // (WIP) Hit testing to allow subsequent widgets to overlap this one

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

#endif

};

ImGuiTabBarFlags_NoCloseWithMiddleMouseButton = 1 << 3, // Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You may handle this behavior manually on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.

ImGuiTabBarFlags_NoTabListScrollingButtons = 1 << 4, // Disable scrolling buttons (apply when fitting policy is ImGuiTabBarFlags_FittingPolicyScroll)

ImGuiTabBarFlags_NoTooltip = 1 << 5, // Disable tooltips when hovering a tab

ImGuiTabBarFlags_FittingPolicyMask_ = ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll,

ImGuiTabBarFlags_FittingPolicyDefault_ = ImGuiTabBarFlags_FittingPolicyResizeDown,

};

ImGuiHoveredFlags_AllowWhenOverlappedByItem = 1 << 8, // IsItemHovered() only: Return true even if the item uses AllowOverlap mode and is overlapped by another hoverable item.

ImGuiHoveredFlags_AllowWhenOverlappedByWindow = 1 << 9, // IsItemHovered() only: Return true even if the position is obstructed or overlapped by another window.

ImGuiHoveredFlags_AllowWhenDisabled = 1 << 10, // IsItemHovered() only: Return true even if the item is disabled

ImGuiHoveredFlags_AllowWhenOverlapped = ImGuiHoveredFlags_AllowWhenOverlappedByItem | ImGuiHoveredFlags_AllowWhenOverlappedByWindow,

ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped,

ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows,

ImGuiDragDropFlags_SourceNoHoldToOpenOthers = 1 << 2, // Disable the behavior that allows to open tree nodes and collapsing header by holding over them while dragging a source item.

ImGuiDragDropFlags_SourceAllowNullID = 1 << 3, // Allow items such as Text(), Image() that have no unique identifier to be used as drag source, by manufacturing a temporary identifier based on their window-relative position. This is extremely unusual within the dear imgui ecosystem and so we made it explicit.

ImGuiDragDropFlags_SourceExtern = 1 << 4, // External source (from outside of dear imgui), won't attempt to read current item/window info. Will always return true. Only one Extern source can be active simultaneously.

// AcceptDragDropPayload() flags

ImGuiDragDropFlags_AcceptBeforeDelivery = 1 << 10, // AcceptDragDropPayload() will returns true even before the mouse button is released. You can then call IsDelivery() to test if the payload needs to be delivered.

ImGuiDragDropFlags_AcceptNoDrawDefaultRect = 1 << 11, // Do not draw the default highlight rectangle when hovering over target.

ImGuiDragDropFlags_AcceptNoPreviewTooltip = 1 << 12, // Request hiding the BeginDragDropSource tooltip from the BeginDragDropTarget site.

ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect, // For peeking ahead and inspecting the payload before delivery.

};

// Standard Drag and Drop payload types. You can define you own payload types using short strings. Types starting with '_' are defined by Dear ImGui.

ImGuiDataType_U64, // unsigned long long / unsigned __int64

ImGuiDataType_Float, // float

ImGuiDataType_Double, // double

ImGuiDataType_COUNT

};

// A cardinal direction

{

ImGuiDir_None = -1,

ImGuiDir_Left = 0,

};

// A sorting direction

{

ImGuiSortDirection_None = 0,

ImGuiSortDirection_Ascending = 1, // Ascending = 0->9, A->Z etc.

ImGuiSortDirection_Descending = 2 // Descending = 9->0, Z->A etc.

};

// A key identifier (ImGuiKey_XXX or ImGuiMod_XXX value): can represent Keyboard, Mouse and Gamepad values.

// Note that "Keys" related to physical keys and are not the same concept as input "Characters", the later are submitted via io.AddInputCharacter().

// The keyboard key enum values are named after the keys on a standard US keyboard, and on other keyboard types the keys reported may not match the keycaps.

enum ImGuiKey : int

{

// Keyboard

ImGuiKey_None = 0,

ImGuiKey_Tab = 512, // == ImGuiKey_NamedKey_BEGIN

ImGuiKey_LeftArrow,

ImGuiKey_RightArrow,

// [Internal] Reserved for mod storage

ImGuiKey_ReservedForModCtrl, ImGuiKey_ReservedForModShift, ImGuiKey_ReservedForModAlt, ImGuiKey_ReservedForModSuper,

// Keyboard Modifiers (explicitly submitted by backend via AddKeyEvent() calls)

// - This is mirroring the data also written to io.KeyCtrl, io.KeyShift, io.KeyAlt, io.KeySuper, in a format allowing

// - In theory the value of keyboard modifiers should be roughly equivalent to a logical or of the equivalent left/right keys.

// In practice: it's complicated; mods are often provided from different sources. Keyboard layout, IME, sticky keys and

// backends tend to interfere and break that equivalence. The safer decision is to relay that ambiguity down to the end-user...

ImGuiMod_None = 0,

ImGuiMod_Shift = 1 << 13, // Shift

ImGuiMod_Alt = 1 << 14, // Option/Menu

ImGuiKey_NamedKey_COUNT = ImGuiKey_NamedKey_END - ImGuiKey_NamedKey_BEGIN,

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

ImGuiKey_ModCtrl = ImGuiMod_Ctrl, ImGuiKey_ModShift = ImGuiMod_Shift, ImGuiKey_ModAlt = ImGuiMod_Alt, ImGuiKey_ModSuper = ImGuiMod_Super, // Renamed in 1.89

//ImGuiKey_KeyPadEnter = ImGuiKey_KeypadEnter, // Renamed in 1.87

#endif

};

{

};

// Configuration flags stored in io.ConfigFlags. Set by user/application.

enum ImGuiConfigFlags_

ImGuiConfigFlags_None = 0,

ImGuiConfigFlags_NavEnableKeyboard = 1 << 0, // Master keyboard navigation enable flag. Enable full Tabbing + directional arrows + space/enter to activate.

ImGuiConfigFlags_NavEnableGamepad = 1 << 1, // Master gamepad navigation enable flag. Backend also needs to set ImGuiBackendFlags_HasGamepad.

ImGuiConfigFlags_NoMouseCursorChange = 1 << 5, // Instruct backend to not alter mouse cursor shape and visibility. Use if the backend cursor changes are interfering with yours and you don't want to use SetMouseCursor() to change mouse cursor. You may want to honor requests from imgui by reading GetMouseCursor() yourself instead.

// User storage (to allow your backend/engine to communicate to code that may be shared between multiple projects. Those flags are NOT used by core Dear ImGui)

ImGuiConfigFlags_IsSRGB = 1 << 20, // Application is SRGB-aware.

ImGuiConfigFlags_IsTouchScreen = 1 << 21, // Application is using a touch screen instead of a mouse.

};

// Backend capabilities flags stored in io.BackendFlags. Set by imgui_impl_xxx or custom backend.

ImGuiBackendFlags_None = 0,

ImGuiBackendFlags_HasGamepad = 1 << 0, // Backend Platform supports gamepad and currently has one connected.

ImGuiBackendFlags_HasMouseCursors = 1 << 1, // Backend Platform supports honoring GetMouseCursor() value to change the OS cursor shape.

ImGuiBackendFlags_RendererHasVtxOffset = 1 << 3, // Backend Renderer supports ImDrawCmd::VtxOffset. This enables output of large meshes (64K+ vertices) while still using 16-bit indices.

};

ImGuiCol_ResizeGrip, // Resize grip in lower-right and lower-left corners of windows.

ImGuiCol_ResizeGripHovered,

ImGuiCol_ResizeGripActive,

ImGuiCol_PlotLines,

ImGuiCol_PlotLinesHovered,

ImGuiCol_PlotHistogram,

ImGuiCol_TableBorderLight, // Table inner borders (prefer using Alpha=1.0 here)

ImGuiCol_TableRowBg, // Table row background (even rows)

ImGuiCol_TableRowBgAlt, // Table row background (odd rows)

ImGuiCol_TextSelectedBg,

ImGuiCol_DragDropTarget, // Rectangle highlighting a drop target

ImGuiCol_NavWindowingHighlight, // Highlight window when using CTRL+TAB

ImGuiCol_NavWindowingDimBg, // Darken/colorize entire screen behind the CTRL+TAB window list, when active

ImGuiCol_ModalWindowDimBg, // Darken/colorize entire screen behind a modal window, when one is active

};

// Enumeration for PushStyleVar() / PopStyleVar() to temporarily modify the ImGuiStyle structure.

// - The enum only refers to fields of ImGuiStyle which makes sense to be pushed/popped inside UI code.

// During initialization or between frames, feel free to just poke into ImGuiStyle directly.

// - Tip: Use your programming IDE navigation facilities on the names in the _second column_ below to find the actual members and their description.

// - When changing this enum, you need to update the associated internal table GStyleVarInfo[] accordingly. This is where we link enum values to members offset/type.

enum ImGuiStyleVar_

{

ImGuiStyleVar_COUNT

};

ImGuiButtonFlags_MouseButtonLeft = 1 << 0, // React on left mouse button (default)

ImGuiButtonFlags_MouseButtonRight = 1 << 1, // React on right mouse button

ImGuiButtonFlags_MouseButtonMiddle = 1 << 2, // React on center mouse button

};

// Flags for ColorEdit3() / ColorEdit4() / ColorPicker3() / ColorPicker4() / ColorButton()

// Flags for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc.

// We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.

enum ImGuiSliderFlags_

{

};

// Identify a mouse button.

ImGuiTableColumnFlags_NoSort = 1 << 9, // Disable ability to sort on this field (even if ImGuiTableFlags_Sortable is set on the table).

ImGuiTableColumnFlags_NoSortAscending = 1 << 10, // Disable ability to sort in the ascending direction.

ImGuiTableColumnFlags_NoSortDescending = 1 << 11, // Disable ability to sort in the descending direction.

ImGuiTableColumnFlags_NoHeaderWidth = 1 << 13, // Disable header text width contribution to automatic column width.

ImGuiTableColumnFlags_PreferSortAscending = 1 << 14, // Make the initial sort direction Ascending when first sorting on this column (default).

ImGuiTableColumnFlags_PreferSortDescending = 1 << 15, // Make the initial sort direction Descending when first sorting on this column.

ImGuiID ColumnUserID; // User id of the column (if specified by a TableSetupColumn() call)

ImS16 ColumnIndex; // Index of the column

ImS16 SortOrder; // Index within parent ImGuiTableSortSpecs (always stored in order starting from 0, tables sorted on a single criteria will always have a 0 here)

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

};

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

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

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

// IM_MALLOC(), IM_FREE(), IM_NEW(), IM_PLACEMENT_NEW(), IM_DELETE()

// We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax.

float FrameBorderSize; // Thickness of border around frames. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).

ImVec2 ItemSpacing; // Horizontal and vertical spacing between widgets/lines.

ImVec2 ItemInnerSpacing; // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).

ImVec2 TouchExtraPadding; // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!

float IndentSpacing; // Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).

float ColumnsMinSpacing; // Minimum horizontal spacing between two columns. Preferably > (FramePadding.x + 1).

float TabBorderSize; // Thickness of border around tabs.

float TabMinWidthForCloseButton; // Minimum width for close button to appear on an unselected tab when hovered. Set to 0.0f to always show when hovering, set to FLT_MAX to never show close button unless selected.

float TabBarBorderSize; // Thickness of tab-bar separator, which takes on the tab active color to denote focus.

float TableAngledHeadersAngle; // Angle of angled headers (supported values range from -50.0f degrees to +50.0f degrees).

ImGuiDir ColorButtonPosition; // Side of the color button in the ColorEdit4 widget (left/right). Defaults to ImGuiDir_Right.

ImVec2 ButtonTextAlign; // Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).

ImVec2 SelectableTextAlign; // Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned). It's generally important to keep this left-aligned if you want to lay multiple items on a same line.

ImVec2 SeparatorTextAlign; // Alignment of text within the separator. Defaults to (0.0f, 0.5f) (left aligned, center).

ImVec2 SeparatorTextPadding; // Horizontal offset of text from each edge of the separator + spacing on other axis. Generally small values. .y is recommended to be == FramePadding.y.

bool AntiAliasedLines; // Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).

bool AntiAliasedLinesUseTex; // Enable anti-aliased lines/borders using textures where possible. Require backend to render with bilinear filtering (NOT point/nearest filtering). Latched at the beginning of the frame (copied to ImDrawList).

bool AntiAliasedFill; // Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.). Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).

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

// Communicate most settings and inputs/outputs to Dear ImGui using this structure.

// Access via ImGui::GetIO(). Read 'Programmer guide' section in .cpp file for general usage.

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

// [Internal] Storage used by IsKeyDown(), IsKeyPressed() etc functions.

// Configuration // Default value

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

ImGuiBackendFlags BackendFlags; // = 0 // See ImGuiBackendFlags_ enum. Set by backend (imgui_impl_xxx files or custom backend) to communicate features supported by the backend.

ImVec2 DisplaySize; // <unset> // Main display size, in pixels (generally == GetMainViewport()->Size). May change every frame.

float DeltaTime; // = 1.0f/60.0f // Time elapsed since last frame, in seconds. May change every frame.

const char* LogFilename; // = "imgui_log.txt"// Path to .log file (default parameter to ImGui::LogToFile when no file is specified).

void* UserData; // = NULL // Store your own data.

ImFontAtlas*Fonts; // <auto> // Font atlas: load, rasterize and pack one or more fonts into a single texture.

float FontGlobalScale; // = 1.0f // Global scale all fonts

ImFont* FontDefault; // = NULL // Font to use on NewFrame(). Use NULL to uses Fonts->Fonts[0].

ImVec2 DisplayFramebufferScale; // = (1, 1) // For retina display or other situations where window coordinates are different from framebuffer coordinates. This generally ends up in ImDrawData::FramebufferScale.

// Miscellaneous options

bool MouseDrawCursor; // = false // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor). Cannot be easily renamed to 'io.ConfigXXX' because this is frequently used by backend implementations.

bool ConfigInputTrickleEventQueue; // = true // Enable input queue trickling: some types of events submitted during the same frame (e.g. button down + up) will be spread over multiple frames, improving interactions with low framerates.

bool ConfigInputTextCursorBlink; // = true // Enable blinking cursor (optional as some users consider it to be distracting).

bool ConfigInputTextEnterKeepActive; // = false // [BETA] Pressing Enter will keep item active and select contents (single-line only).

bool ConfigDragClickToInputText; // = false // [BETA] Enable turning DragXXX widgets into text input with a simple mouse click-release (without moving). Not desirable on devices without a keyboard.

float ConfigMemoryCompactTimer; // = 60.0f // Timer (in seconds) to free transient windows/tables memory buffers when unused. Set to -1.0f to disable.

// Inputs Behaviors

// Debug options

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

// Option to enable various debug tools showing buttons that will call the IM_DEBUG_BREAK() macro.

// - The Item Picker tool will be available regardless of this being enabled, in order to maximize its discoverability.

// - Requires a debugger being attached, otherwise IM_DEBUG_BREAK() options will appear to crash your application.

// e.g. io.ConfigDebugIsDebuggerPresent = ::IsDebuggerPresent() on Win32, or refer to ImOsIsDebuggerPresent() imgui_test_engine/imgui_te_utils.cpp for a Unix compatible version).

bool ConfigDebugIsDebuggerPresent; // = false // Enable various tools calling IM_DEBUG_BREAK().

// Tools to test correct Begin/End and BeginChild/EndChild behaviors.

// - Presently Begin()/End() and BeginChild()/EndChild() needs to ALWAYS be called in tandem, regardless of return value of BeginXXX()

// - This is inconsistent with other BeginXXX functions and create confusion for many users.

// Option to deactivate io.AddFocusEvent(false) handling.

// - May facilitate interactions with a debugger when focus loss leads to clearing inputs data.

// - Backends may have other side-effects on focus loss, so this will reduce side-effects but not necessary remove all of them.

bool ConfigDebugIniSettings; // = false // Save .ini data with extra comments (particularly helpful for Docking, but makes saving slower)

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

// (the imgui_impl_xxxx backend files are setting those up for you)

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

void* BackendRendererUserData; // = NULL // User data for renderer backend

void* BackendLanguageUserData; // = NULL // User data for non C++ programming language backend

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

// Input - Call before calling NewFrame()

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

IMGUI_API void SetKeyEventNativeData(ImGuiKey key, int native_keycode, int native_scancode, int native_legacy_index = -1); // [Optional] Specify index for legacy <1.87 IsKeyXXX() functions with native indices + specify native keycode, scancode.

IMGUI_API void SetAppAcceptingEvents(bool accepting_events); // Set master flag for accepting key/mouse/text events (default to true). Useful if you have native dialog boxes that are interrupting your application loop/refresh, and you want to disable events being queued while your app is frozen.

IMGUI_API void ClearEventsQueue(); // Clear all incoming events.

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

IMGUI_API void ClearInputCharacters(); // [Obsoleted in 1.89.8] Clear the current frame text input buffer. Now included within ClearInputKeys().

#endif

bool WantCaptureMouse; // Set when Dear ImGui will use mouse inputs, in this case do not dispatch them to your main game/application (either way, always pass on mouse inputs to imgui). (e.g. unclicked mouse is hovering over an imgui window, widget is active, mouse was clicked over an imgui window, etc.).

bool WantCaptureKeyboard; // Set when Dear ImGui will use keyboard inputs, in this case do not dispatch them to your main game/application (either way, always pass keyboard inputs to imgui). (e.g. InputText active, or an imgui window is focused and navigation is enabled, etc.).

bool WantTextInput; // Mobile/console: when set, you may display an on-screen keyboard. This is set by Dear ImGui when it wants textual keyboard input to happen (e.g. when a InputText widget is active).

bool WantSaveIniSettings; // When manual .ini load/save is active (io.IniFilename == NULL), this will be set to notify your application that you can call SaveIniSettingsToMemory() and save yourself. Important: clear io.WantSaveIniSettings yourself after saving!

bool NavActive; // Keyboard/Gamepad navigation is currently allowed (will handle ImGuiKey_NavXXX events) = a window is focused and it doesn't use the ImGuiWindowFlags_NoNavInputs flag.

float Framerate; // Estimate of application framerate (rolling average over 60 frames, based on io.DeltaTime), in frame per second. Solely for convenience. Slow applications may not want to use a moving average or may want to reset underlying buffers occasionally.

int MetricsRenderVertices; // Vertices output during last call to Render()

int MetricsRenderIndices; // Indices output during last call to Render() = number of triangles * 3

int MetricsActiveWindows; // Number of active windows

ImVec2 MouseDelta; // Mouse delta. Note that this is zero if either current or previous position are invalid (-FLT_MAX,-FLT_MAX), so a disappearing/reappearing mouse won't have a huge delta.

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

// [Internal] Dear ImGui will maintain those fields. Forward compatibility not guaranteed!

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

bool KeySuper; // Keyboard modifier down: Cmd/Super/Windows

// Other state maintained from data above + IO function calls

bool WantCaptureMouseUnlessPopupClose; // Alternative to WantCaptureMouse: (WantCaptureMouse == true && WantCaptureMouseUnlessPopupClose == false) when a click over void is expected to close a popup.

ImVec2 MousePosPrev; // Previous mouse position (note that MouseDelta is not necessary == MousePos-MousePosPrev, in case either position is invalid)

ImVec2 MouseClickedPos[5]; // Position at time of clicking

bool MouseDownOwned[5]; // Track if button was clicked inside a dear imgui window or over void blocked by a popup. We don't request mouse capture from the application if click started outside ImGui bounds.

bool MouseDownOwnedUnlessPopupClose[5]; // Track if button was clicked inside a dear imgui window.

bool MouseWheelRequestAxisSwap; // On a non-Mac system, holding SHIFT requests WheelY to perform the equivalent of a WheelX event. On a Mac system this is already enforced by the system.

float MouseDownDuration[5]; // Duration the mouse button has been down (0.0f == just clicked)

float MouseDownDurationPrev[5]; // Previous time the mouse button has been down

float MouseDragMaxDistanceSqr[5]; // Squared maximum distance of how much mouse has traveled from the clicking point (used for moving thresholds)

float PenPressure; // Touch/Pen pressure (0.0f to 1.0f, should be >0.0f only when MouseDown[0] == true). Helper storage currently unused by Dear ImGui.

bool AppFocusLost; // Only modify via AddFocusEvent()

bool AppAcceptingEvents; // Only modify via SetAppAcceptingEvents()

ImWchar16 InputQueueSurrogate; // For AddInputCharacterUTF16()

ImVector<ImWchar> InputQueueCharacters; // Queue of _characters_ input (obtained by platform backend). Fill using AddInputCharacter() helper.

IMGUI_API ImGuiIO();

};

void* UserData; // What user passed to InputText() // Read-only

// Arguments for the different callback events

// - To modify the text buffer in a callback, prefer using the InsertChars() / DeleteChars() function. InsertChars() will take care of calling the resize callback if necessary.

// - If you know your edits are not going to resize the underlying buffer allocation, you may modify the contents of 'Buf[]' directly. You need to update 'BufTextLen' accordingly (0 <= BufTextLen < BufSize) and set 'BufDirty'' to true so InputText can update its internal state.

ImWchar EventChar; // Character input // Read-write // [CharFilter] Replace character with another one, or set to zero to drop. return 1 is equivalent to setting EventChar=0;

IMGUI_API void appendfv(const char* fmt, va_list args) IM_FMTLIST(2);

};

// Helper: Key->Value storage

// Typically you don't have to worry about this since a storage is held within each Window.

// We use it to e.g. store collapse state for a tree (Int 0/1)

struct ImGuiStorage

{

// [Internal]

ImVector<ImGuiStoragePair> Data;

// - Get***() functions find pair, never add/allocate. Pairs are sorted so a query is O(log N)

IMGUI_API void BuildSortByKey();

// Obsolete: use on your own storage if you know only integer are being stored (open/close all tree nodes)

IMGUI_API void SetAllInt(int val);

};

// Helper: Manually clip large list of items.

int ItemsCount; // [Internal] Number of items

float ItemsHeight; // [Internal] Height of item after a first step and item submission can calculate it

float StartPosY; // [Internal] Cursor position at the time of Begin() or after table frozen rows are all processed

void* TempData; // [Internal] Internal data

// items_height: Use -1.0f to be calculated automatically on first step. Otherwise pass in the distance between your items, typically GetTextLineHeightWithSpacing() or GetFrameHeightWithSpacing().

IMGUI_API ImGuiListClipper();

IMGUI_API ~ImGuiListClipper();

inline void IncludeItemByIndex(int item_index) { IncludeItemsByIndex(item_index, item_index + 1); }

IMGUI_API void IncludeItemsByIndex(int item_begin, int item_end); // item_end is exclusive e.g. use (42, 42+1) to make item 42 never clipped.

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

inline void IncludeRangeByIndices(int item_begin, int item_end) { IncludeItemsByIndex(item_begin, item_end); } // [renamed in 1.89.9]

inline void ForceDisplayRangeByIndices(int item_begin, int item_end) { IncludeItemsByIndex(item_begin, item_end); } // [renamed in 1.89.6]

// Helpers: ImVec2/ImVec4 operators

// - It is important that we are keeping those disabled by default so they don't leak in user space.

// - This is in order to allow user enabling implicit cast operators between ImVec2/ImVec4 and their own types (using IM_VEC2_CLASS_EXTRA in imconfig.h)

#ifdef IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED

IM_MSVC_RUNTIME_CHECKS_OFF

static ImColor HSV(float h, float s, float v, float a = 1.0f) { float r, g, b; ImGui::ColorConvertHSVtoRGB(h, s, v, r, g, b); return ImColor(r, g, b, a); }

};