pwmgr

// dear imgui, v1.91.5

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

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

#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 IM_STRINGIFY_HELPER(_X) #_X

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

#define IM_FLOOR IM_TRUNC

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }

static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t) { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }

static inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t) { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }

static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }

static inline float ImLengthSqr(const ImVec2& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y); }

static inline float ImLengthSqr(const ImVec4& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y) + (lhs.z * lhs.z) + (lhs.w * lhs.w); }

static inline float ImInvLength(const ImVec2& lhs, float fail_value) { float d = (lhs.x * lhs.x) + (lhs.y * lhs.y); if (d > 0.0f) return ImRsqrt(d); return fail_value; }

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

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

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

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

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

static inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; }

static inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a) { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }

static inline float ImLinearSweep(float current, float target, float speed) { if (current < target) return ImMin(current + speed, target); if (current > target) return ImMax(current - speed, target); return current; }

static inline float ImLinearRemapClamp(float s0, float s1, float d0, float d1, float x) { return ImSaturate((x - s0) / (s1 - s0)) * (d1 - d0) + d0; }

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

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

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

ImVector<int> LineOffsets;

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

int size() { return LineOffsets.Size; }

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

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

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

ImVec2 TexUvWhitePixel; // UV of white pixel in the atlas

ImFont* Font; // Current/default font (optional, for simplified AddText overload)

float FontSize; // Current/default font size (optional, for simplified AddText overload)

float FontScale; // Current/default font scale (== FontSize / Font->FontSize)

ImVec4 ClipRectFullscreen; // Value for PushClipRectFullscreen()

// [Internal] Temp write buffer

ImVector<ImVec2> TempBuffer;

// [Internal] Lookup tables

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

// [SECTION] Data types support

struct ImGuiDataVarInfo

ImGuiDataType Type;

ImU32 Count; // 1+

ImU32 Offset; // Offset in parent structure

ImGuiDataType_String = ImGuiDataType_COUNT + 1,

ImGuiDataType_Pointer,

//ImGuiButtonFlags_Repeat = 1 << 10, // hold to repeat

ImGuiSelectableFlags_SelectOnNav = 1 << 21, // (WIP) Auto-select when moved into. This is not exposed in public API as to handle multi-select and modifiers we will need user to explicitly control focus scope. May be replaced with a BeginSelection() API.

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

struct ImGuiColorMod

{

ImGuiCol Col;

ImVec4 BackupValue;

};

// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.

struct ImGuiStyleMod

{

ImGuiStyleVar VarIdx;

union { int BackupInt[2]; float BackupFloat[2]; };

ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; }

ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; }

ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }

};

bool BackupActiveIdPreviousFrameIsAlive;

ImGuiInputTextFlags Flags; // copy of InputText() flags. may be used to check if e.g. ImGuiInputTextFlags_Password is set.

bool ReloadUserBuf; // force a reload of user buf so it may be modified externally. may be automatic in future version.

int ReloadSelectionStart; // POSITIONS ARE IN IMWCHAR units *NOT* UTF-8 this is why this is not exposed yet.

ImGuiNextWindowDataFlags_HasChildFlags = 1 << 8,

ImGuiNextWindowDataFlags_HasRefreshPolicy = 1 << 9,

ImGuiNextWindowDataFlags Flags;

inline void ClearFlags() { Flags = ImGuiNextWindowDataFlags_None; }

// Non-flags members are NOT cleared by ItemAdd() meaning they are still valid during NavProcessItem()

ImGuiItemFlags ItemFlags; // See ImGuiItemFlags_

// Rarely used fields are not explicitly cleared, only valid when the corresponding ImGuiItemStatusFlags ar set.

// - To implement ImGuiTreeNodeFlags_NavLeftJumpsBackHere: store the minimum amount of data

ImGuiItemFlags ItemFlags; // Used for nav landing

ImRect NavRect; // Used for nav landing

enum ImGuiInputSource

ImU8 RoutingCurrScore; // [DEBUG] For debug display

ImU8 RoutingNextScore; // Lower is better (0: perfect score)

ImGuiKeyRoutingData() { NextEntryIndex = -1; Mods = 0; RoutingCurrScore = RoutingNextScore = 255; RoutingCurr = RoutingNext = ImGuiKeyOwner_NoOwner; }

ImGuiActivateFlags_FromTabbing = 1 << 3, // Activation requested by a tabbing request

ImGuiNavMoveFlags_ScrollToEdgeY = 1 << 6, // Force scrolling to min/max (used by Home/End) // FIXME-NAV: Aim to remove or reword, probably unnecessary

ImGuiDebugLogFlags_EventInputRouting = 1 << 8,

ImGuiDebugLogFlags_EventDocking = 1 << 9, // Unused in this branch

ImGuiDebugLogFlags_EventViewport = 1 << 10, // Unused in this branch

ImGuiDebugLogFlags_EventMask_ = ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport,

bool ShowAtlasTintedWithTextColor = false;

ImS8 QueryFrameCount; // >= 1: Query in progress

bool QuerySuccess; // Obtained result from DebugHookIdInfo()

ImGuiDataType DataType : 8;

char Desc[57]; // Arbitrarily sized buffer to hold a result (FIXME: could replace Results[] with a chunk stream?) FIXME: Now that we added CTRL+C this should be fixed.

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

int StackLevel; // -1: query stack and resize Results, >= 0: individual stack level

ImGuiID QueryId; // ID to query details for

ImVector<ImGuiStackLevelInfo> Results;

bool CopyToClipboardOnCtrlC;

ImGuiIDStackTool() { memset(this, 0, sizeof(*this)); CopyToClipboardLastTime = -FLT_MAX; }

bool FontAtlasOwnedByContext; // IO.Fonts-> is owned by the ImGuiContext and will be destructed along with it.

ImFont* Font; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()

float FontSize; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.

float FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.

float FontScale; // == FontSize / Font->FontSize

float CurrentDpiScale; // Current window/viewport DpiScale

double Time;

int FrameCount;

int FrameCountEnded;

int FrameCountRendered;

bool WithinFrameScope; // Set by NewFrame(), cleared by EndFrame()

bool WithinFrameScopeWithImplicitWindow; // Set by NewFrame(), cleared by EndFrame() when the implicit debug window has been pushed

bool WithinEndChild; // Set within EndChild()

bool GcCompactAll; // Request full GC

bool TestEngineHookItems; // Will call test engine hooks: ImGuiTestEngineHook_ItemAdd(), ImGuiTestEngineHook_ItemInfo(), ImGuiTestEngineHook_Log()

char ContextName[16]; // Storage for a context name (to facilitate debugging multi-context setups)

ImVec2 WindowsHoverPadding; // Padding around resizable windows for which hovering on counts as hovering the window == ImMax(style.TouchExtraPadding, WINDOWS_HOVER_PADDING).

ImGuiID DebugDrawIdConflicts; // Set when we detect multiple items with the same identifier

ImGuiID DebugHookIdInfo; // Will call core hooks: DebugHookIdInfo() from GetID functions, used by ID Stack Tool [next HoveredId/ActiveId to not pull in an extra cache-line]

int ActiveIdMouseButton : 8;

ImGuiWindow* ActiveIdWindow;

bool ActiveIdPreviousFrameIsAlive;

bool ActiveIdPreviousFrameHasBeenEditedBefore;

ImGuiWindow* ActiveIdPreviousFrameWindow;

ImVector<ImFont*> FontStack; // Stack for PushFont()/PopFont() - inherited by Begin()

ImGuiID NavActivateId; // ~~ (g.ActiveId == 0) && (IsKeyPressed(ImGuiKey_Space) || IsKeyDown(ImGuiKey_Enter) || IsKeyPressed(ImGuiKey_NavGamepadActivate)) ? NavId : 0, also set when calling ActivateItem()

ImGuiID NavNextActivateId; // Set by ActivateItem(), queued until next frame.

ImGuiInputSource NavInputSource; // Keyboard or Gamepad mode? THIS CAN ONLY BE ImGuiInputSource_Keyboard or ImGuiInputSource_Mouse

// Navigation: Windowing (CTRL+TAB for list, or Menu button + keys or directional pads to move/resize)

ImGuiWindow* NavWindowingTarget; // Target window when doing CTRL+Tab (or Pad Menu + FocusPrev/Next), this window is temporarily displayed top-most!

ImGuiWindow* NavWindowingListWindow; // Internal window actually listing the CTRL+Tab contents

bool NavWindowingToggleLayer;

ImGuiKey NavWindowingToggleKey;

float DimBgRatio; // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)

ImGuiDragDropFlags DragDropAcceptFlags;

ImFont InputTextPasswordFont;

ImGuiID TempInputId; // Temporary text input when CTRL+clicking on a slider, etc.

ImGuiPlatformImeData PlatformImeData; // Data updated by current frame

const char* LogNextPrefix;

bool LogLineFirstItem;

int DebugDrawIdConflictsCount; // Locked count (preserved when holding CTRL)

int WantTextInputNextFrame;

ImU32 TreeHasStackDataDepthMask; // Store whether given depth has ImGuiTreeNodeStackData data. Could be turned into a ImU64 if necessary.

ImGuiDir AutoPosLastDirection;

ImGuiWindow* ParentWindowForFocusRoute; // Set to manual link a window to its logical parent so that Shortcut() chain are honoerd (e.g. Tool linked to Document)

float CalcFontSize() const { ImGuiContext& g = *Ctx; float scale = g.FontBaseSize * FontWindowScale; if (ParentWindow) scale *= ParentWindow->FontWindowScale; return scale; }

float ContentWidth; // Width of label, stored during BeginTabItem() call

ImGuiID VisibleTabId; // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)

#define IMGUI_TABLE_MAX_COLUMNS 512 // May be further lifted

// Our current column maximum is 64 but we may raise that in the future.

typedef ImS16 ImGuiTableColumnIdx;

typedef ImU16 ImGuiTableDrawChannelIdx;

void* RawData; // Single allocation to hold Columns[], DisplayOrderToIndex[] and RowCellData[]

ImS16 InstanceCurrent; // Count of BeginTable() calls with same ID in the same frame (generally 0). This is a little bit similar to BeginCount for a window, but multiple table with same ID look are multiple tables, they are just synched.

ImRect InnerRect; // InnerRect but without decoration. As with OuterRect, for non-scrolling tables, InnerRect.Max.y is

bool DisableDefaultContextMenu; // Disable default context menu contents. You may submit your own using TableBeginContextMenuPopup()/EndPopup()

bool IsSettingsDirty; // Set when table settings have changed and needs to be reported into ImGuiTableSetttings data.

// sizeof() ~ 12

ImU8 IsEnabled : 1; // "Visible" in ini file

IsEnabled = 1;

IMGUI_API ImGuiIO& GetIOEx(ImGuiContext* ctx);

IMGUI_API void SetCurrentFont(ImFont* font);

inline ImFont* GetDefaultFont() { ImGuiContext& g = *GImGui; return g.IO.FontDefault ? g.IO.FontDefault : g.IO.Fonts->Fonts[0]; }

IMGUI_API void UpdateHoveredWindowAndCaptureFlags();

IMGUI_API void SetLastItemData(ImGuiID item_id, ImGuiItemFlags in_flags, ImGuiItemStatusFlags status_flags, const ImRect& item_rect);

IMGUI_API void ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess);

IMGUI_API const ImGuiDataVarInfo* GetStyleVarInfo(ImGuiStyleVar idx);

IMGUI_API void NavMoveRequestResolveWithPastTreeNode(ImGuiNavItemData* result, ImGuiTreeNodeStackData* tree_node_data);

IMGUI_API void ActivateItemByID(ImGuiID id); // Activate an item by ID (button, checkbox, tree node etc.). Activation is queued and processed on the next frame when the item is encountered again.