Added imgui for configuration

1 files changed, 616 insertions, 0 deletions

diff --git a/vendor/zgui/libs/imgui_test_engine/imgui_te_context.h b/vendor/zgui/libs/imgui_test_engine/imgui_te_context.h
new file mode 100644
index 0000000..a469f60
--- /dev/null
+++ b/vendor/zgui/libs/imgui_test_engine/imgui_te_context.h
@@ -0,0 +1,616 @@
+// dear imgui test engine
+// (context when a running test + end user automation API)
+// This is the main (if not only) interface that your Tests will be using.
+
+#pragma once
+
+#include "imgui.h"
+#include "imgui_internal.h"     // ImGuiAxis, ImGuiItemStatusFlags, ImGuiInputSource, ImGuiWindow
+#include "imgui_te_engine.h"    // ImGuiTestStatus, ImGuiTestRunFlags, ImGuiTestActiveFunc, ImGuiTestItemInfo, ImGuiTestLogFlags
+
+/*
+
+Index of this file:
+// [SECTION] Header mess, warnings
+// [SECTION] Forward declarations
+// [SECTION] ImGuiTestRef
+// [SECTION] Helper keys
+// [SECTION] ImGuiTestContext related Flags/Enumerations
+// [SECTION] ImGuiTestGenericVars, ImGuiTestGenericItemStatus
+// [SECTION] ImGuiTestContext
+// [SECTION] Debugging macros: IM_SUSPEND_TESTFUNC()
+// [SECTION] Testing/Checking macros: IM_CHECK(), IM_ERRORF() etc.
+
+*/
+
+//-------------------------------------------------------------------------
+// [SECTION] Header mess, warnings
+//-------------------------------------------------------------------------
+
+// Undo some of the damage done by <windows.h>
+#ifdef Yield
+#undef Yield
+#endif
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-pragmas"                // warning: unknown warning group 'xxx'
+#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
+#endif
+
+//-------------------------------------------------------------------------
+// [SECTION] Forward declarations
+//-------------------------------------------------------------------------
+
+// This file
+typedef int ImGuiTestOpFlags;       // Flags: See ImGuiTestOpFlags_
+
+// External: imgui
+struct ImGuiDockNode;
+struct ImGuiTabBar;
+struct ImGuiWindow;
+
+// External: test engine
+struct ImGuiTest;                   // A test registered with IM_REGISTER_TEST()
+struct ImGuiTestEngine;             // Test Engine Instance (opaque)
+struct ImGuiTestEngineIO;           // Test Engine IO structure (configuration flags, state)
+struct ImGuiTestItemInfo;           // Information gathered about an item: label, status, bounding box etc.
+struct ImGuiTestItemList;           // Result of an GatherItems() query
+struct ImGuiTestInputs;             // Test Engine Simulated Inputs structure (opaque)
+struct ImGuiTestGatherTask;         // Test Engine task for scanning/finding items
+struct ImGuiCaptureArgs;            // Parameters for ctx->CaptureXXX functions
+enum ImGuiTestVerboseLevel : int;
+
+//-------------------------------------------------------------------------
+// [SECTION] ImGuiTestRef
+//-------------------------------------------------------------------------
+
+// Weak reference to an Item/Window given an hashed ID _or_ a string path ID.
+// This is most often passed as argument to function and generally has a very short lifetime.
+// Documentation: https://github.com/ocornut/imgui_test_engine/wiki/Named-References
+// (SUGGESTION: add those constructors to "VA Step Filter" (Visual Assist) or a .natstepfilter file (Visual Studio) so they are skipped by F11 (StepInto)
+struct IMGUI_API ImGuiTestRef
+{
+    ImGuiID         ID;             // Pre-hashed ID
+    const char*     Path;           // Relative or absolute path (string pointed to, not owned, as our lifetime is very short)
+
+    ImGuiTestRef()                  { ID = 0; Path = NULL; }
+    ImGuiTestRef(ImGuiID id)        { ID = id; Path = NULL; }
+    ImGuiTestRef(const char* path)  { ID = 0; Path = path; }
+    bool IsEmpty() const            { return ID == 0 && (Path == NULL || Path[0] == 0); }
+};
+
+// Debug helper to output a string showing the Path, ID or Debug Label based on what is available (some items only have ID as we couldn't find/store a Path)
+// (The size is arbitrary, this is only used for logging info the user/debugger)
+struct IMGUI_API ImGuiTestRefDesc
+{
+    char            Buf[80];
+
+    const char* c_str()             { return Buf; }
+    ImGuiTestRefDesc(const ImGuiTestRef& ref, const ImGuiTestItemInfo* item);
+};
+
+//-------------------------------------------------------------------------
+// [SECTION] ImGuiTestContext related Flags/Enumerations
+//-------------------------------------------------------------------------
+
+// Named actions. Generally you will call the named helpers e.g. ItemClick(). This is used by shared/low-level functions such as ItemAction().
+enum ImGuiTestAction
+{
+    ImGuiTestAction_Unknown = 0,
+    ImGuiTestAction_Hover,          // Move mouse
+    ImGuiTestAction_Click,          // Move mouse and click
+    ImGuiTestAction_DoubleClick,    // Move mouse and double-click
+    ImGuiTestAction_Check,          // Check item if unchecked (Checkbox, MenuItem or any widget reporting ImGuiItemStatusFlags_Checkable)
+    ImGuiTestAction_Uncheck,        // Uncheck item if checked
+    ImGuiTestAction_Open,           // Open item if closed (TreeNode, BeginMenu or any widget reporting ImGuiItemStatusFlags_Openable)
+    ImGuiTestAction_Close,          // Close item if opened
+    ImGuiTestAction_Input,          // Start text inputing into a field (e.g. CTRL+Click on Drags/Slider, click on InputText etc.)
+    ImGuiTestAction_NavActivate,    // Activate item with navigation
+    ImGuiTestAction_COUNT
+};
+
+// Generic flags for many ImGuiTestContext functions
+enum ImGuiTestOpFlags_
+{
+    ImGuiTestOpFlags_None               = 0,
+    ImGuiTestOpFlags_NoCheckHoveredId   = 1 << 1,   // Don't check for HoveredId after aiming for a widget. A few situations may want this: while e.g. dragging or another items prevents hovering, or for items that don't use ItemHoverable()
+    ImGuiTestOpFlags_NoError            = 1 << 2,   // Don't abort/error e.g. if the item cannot be found or the operation doesn't succeed.
+    ImGuiTestOpFlags_NoFocusWindow      = 1 << 3,   // Don't focus window when aiming at an item
+    ImGuiTestOpFlags_NoAutoUncollapse   = 1 << 4,   // Disable automatically uncollapsing windows (useful when specifically testing Collapsing behaviors)
+    ImGuiTestOpFlags_NoAutoOpenFullPath = 1 << 5,   // Disable automatically opening intermediaries (e.g. ItemClick("Hello/OK") will automatically first open "Hello" if "OK" isn't found. Only works if ref is a string path.
+    ImGuiTestOpFlags_IsSecondAttempt    = 1 << 6,   // Used by recursing functions to indicate a second attempt
+    ImGuiTestOpFlags_MoveToEdgeL        = 1 << 7,   // Simple Dumb aiming helpers to test widget that care about clicking position. May need to replace will better functionalities.
+    ImGuiTestOpFlags_MoveToEdgeR        = 1 << 8,
+    ImGuiTestOpFlags_MoveToEdgeU        = 1 << 9,
+    ImGuiTestOpFlags_MoveToEdgeD        = 1 << 10,
+};
+
+// Advanced filtering for ItemActionAll()
+struct IMGUI_API ImGuiTestActionFilter
+{
+    int                     MaxDepth;
+    int                     MaxPasses;
+    const int*              MaxItemCountPerDepth;
+    ImGuiItemStatusFlags    RequireAllStatusFlags;
+    ImGuiItemStatusFlags    RequireAnyStatusFlags;
+
+    ImGuiTestActionFilter() { MaxDepth = -1; MaxPasses = -1; MaxItemCountPerDepth = NULL; RequireAllStatusFlags = RequireAnyStatusFlags = 0; }
+};
+
+//-------------------------------------------------------------------------
+// [SECTION] ImGuiTestGenericVars, ImGuiTestGenericItemStatus
+//-------------------------------------------------------------------------
+
+// Helper struct to store various query-able state of an item.
+// This facilitate interactions between GuiFunc and TestFunc, since those state are frequently used.
+struct IMGUI_API ImGuiTestGenericItemStatus
+{
+    int     RetValue;               // return value
+    int     Hovered;                // result of IsItemHovered()
+    int     Active;                 // result of IsItemActive()
+    int     Focused;                // result of IsItemFocused()
+    int     Clicked;                // result of IsItemClicked()
+    int     Visible;                // result of IsItemVisible()
+    int     Edited;                 // result of IsItemEdited()
+    int     Activated;              // result of IsItemActivated()
+    int     Deactivated;            // result of IsItemDeactivated()
+    int     DeactivatedAfterEdit;   // result of IsItemDeactivatedAfterEdit()
+
+    ImGuiTestGenericItemStatus()        { Clear(); }
+    void Clear()                        { memset(this, 0, sizeof(*this)); }
+    void QuerySet(bool ret_val = false) { Clear(); QueryInc(ret_val); }
+    void QueryInc(bool ret_val = false) { RetValue += ret_val; Hovered += ImGui::IsItemHovered(); Active += ImGui::IsItemActive(); Focused += ImGui::IsItemFocused(); Clicked += ImGui::IsItemClicked(); Visible += ImGui::IsItemVisible(); Edited += ImGui::IsItemEdited(); Activated += ImGui::IsItemActivated(); Deactivated += ImGui::IsItemDeactivated(); DeactivatedAfterEdit += ImGui::IsItemDeactivatedAfterEdit(); }
+};
+
+// Generic structure with various storage fields.
+// This is useful for tests to quickly share data between GuiFunc and TestFunc without creating custom data structure.
+// If those fields are not enough: using test->SetVarsDataType<>() + ctx->GetVars<>() it is possible to store custom data.
+struct IMGUI_API ImGuiTestGenericVars
+{
+    // Generic storage with a bit of semantic to make user/test code look neater
+    int                     Step;
+    int                     Count;
+    ImGuiID                 DockId;
+    ImGuiID                 OwnerId;
+    ImGuiWindowFlags        WindowFlags;
+    ImGuiTableFlags         TableFlags;
+    ImGuiPopupFlags         PopupFlags;
+    ImGuiTestGenericItemStatus  Status;
+    bool                    ShowWindow1, ShowWindow2;
+    bool                    UseClipper;
+    bool                    UseViewports;
+    float                   Width;
+    ImVec2                  Pos;
+    ImVec2                  Size;
+    ImVec2                  Pivot;
+    ImVec4                  Color1, Color2;
+
+    // Generic unnamed storage
+    int                     Int1, Int2, IntArray[10];
+    float                   Float1, Float2, FloatArray[10];
+    bool                    Bool1, Bool2, BoolArray[10];
+    ImGuiID                 Id, IdArray[10];
+    char                    Str1[256], Str2[256];
+
+    ImGuiTestGenericVars()  { Clear(); }
+    void Clear()            { memset(this, 0, sizeof(*this)); }
+};
+
+//-------------------------------------------------------------------------
+// [SECTION] ImGuiTestContext
+// Context for a running ImGuiTest
+// This is the interface that most tests will interact with.
+//-------------------------------------------------------------------------
+
+struct IMGUI_API ImGuiTestContext
+{
+    // User variables
+    ImGuiTestGenericVars    GenericVars;                            // Generic variables holder for convenience.
+    void*                   UserVars = NULL;                        // Access using ctx->GetVars<Type>(). Setup with test->SetVarsDataType<>().
+
+    // Public fields
+    ImGuiContext*           UiContext = NULL;                       // UI context
+    ImGuiTestEngineIO*      EngineIO = NULL;                        // Test Engine IO/settings
+    ImGuiTest*              Test = NULL;                            // Test currently running
+    ImGuiTestOutput*        TestOutput = NULL;                      // Test output (generally == &Test->Output)
+    ImGuiTestOpFlags        OpFlags = ImGuiTestOpFlags_None;        // Flags affecting all operation (supported: ImGuiTestOpFlags_NoAutoUncollapse)
+    int                     PerfStressAmount = 0;                   // Convenience copy of engine->IO.PerfStressAmount
+    int                     FrameCount = 0;                         // Test frame count (restarts from zero every time)
+    int                     FirstTestFrameCount = 0;                // First frame where TestFunc is running (after warm-up frame). This is generally -1 or 0 depending on whether we have warm up enabled
+    bool                    FirstGuiFrame = false;
+    bool                    HasDock = false;                        // #ifdef IMGUI_HAS_DOCK expressed in an easier to test value
+    ImGuiCaptureArgs*       CaptureArgs = NULL;                     // Capture settings used by ctx->Capture*() functions
+
+    //-------------------------------------------------------------------------
+    // [Internal Fields]
+    //-------------------------------------------------------------------------
+
+    ImGuiTestEngine*        Engine = NULL;
+    ImGuiTestInputs*        Inputs = NULL;
+    ImGuiTestRunFlags       RunFlags = ImGuiTestRunFlags_None;
+    ImGuiTestActiveFunc     ActiveFunc = ImGuiTestActiveFunc_None;  // None/GuiFunc/TestFunc
+    double                  RunningTime = 0.0;                      // Amount of wall clock time the Test has been running. Used by safety watchdog.
+    int                     ActionDepth = 0;                        // Nested depth of ctx-> function calls (used to decorate log)
+    int                     CaptureCounter = 0;                     // Number of captures
+    int                     ErrorCounter = 0;                       // Number of errors (generally this maxxes at 1 as most functions will early out)
+    bool                    Abort = false;
+    double                  PerfRefDt = -1.0;
+    int                     PerfIterations = 400;                   // Number of frames for PerfCapture() measurements
+    char                    RefStr[256] = { 0 };                    // Reference window/path over which all named references are based
+    ImGuiID                 RefID = 0;                              // Reference ID over which all named references are based
+    ImGuiID                 RefWindowID = 0;                        // ID of a window that contains RefID item
+    ImGuiInputSource        InputMode = ImGuiInputSource_Mouse;     // Prefer interacting with mouse/keyboard/gamepad
+    ImVector<char>          Clipboard;                              // Private clipboard for the test instance
+    ImVector<ImGuiWindow*>  ForeignWindowsToHide;
+    ImGuiTestItemInfo       DummyItemInfoNull;                      // Storage for ItemInfoNull()
+    bool                    CachedLinesPrintedToTTY = false;
+
+    //-------------------------------------------------------------------------
+    // Public API
+    //-------------------------------------------------------------------------
+
+    // Main control
+    void            RecoverFromUiContextErrors();
+    void            Finish(ImGuiTestStatus status = ImGuiTestStatus_Success);                       // Set test status and stop running. Usually called when running test logic from GuiFunc() only.
+    ImGuiTestStatus RunChildTest(const char* test_name, ImGuiTestRunFlags flags = 0);               // [Experimental] Run another test from the current test.
+    template <typename T> T& GetVars()      { IM_ASSERT(UserVars != NULL); return *(T*)(UserVars); }// Campanion to using t->SetVarsDataType<>(). FIXME: Assert to compare sizes
+
+    // Main status queries
+    bool        IsError() const             { return TestOutput->Status == ImGuiTestStatus_Error || Abort; }
+    bool        IsWarmUpGuiFrame() const    { return FrameCount < FirstTestFrameCount; }    // Unless test->Flags has ImGuiTestFlags_NoGuiWarmUp, we run GuiFunc() twice before running TestFunc(). Those frames are called "WarmUp" frames.
+    bool        IsFirstGuiFrame() const     { return FirstGuiFrame; }
+    bool        IsFirstTestFrame() const    { return FrameCount == FirstTestFrameCount; }   // First frame where TestFunc is running (after warm-up frame).
+    bool        IsGuiFuncOnly() const       { return (RunFlags & ImGuiTestRunFlags_GuiFuncOnly) != 0; }
+
+    // Debugging
+    bool        SuspendTestFunc(const char* file = NULL, int line = 0);             // [DEBUG] Generally called via IM_SUSPEND_TESTFUNC
+
+    // Logging
+    void        LogEx(ImGuiTestVerboseLevel level, ImGuiTestLogFlags flags, const char* fmt, ...) IM_FMTARGS(4);
+    void        LogExV(ImGuiTestVerboseLevel level, ImGuiTestLogFlags flags, const char* fmt, va_list args) IM_FMTLIST(4);
+    void        LogToTTY(ImGuiTestVerboseLevel level, const char* message, const char* message_end = NULL);
+    void        LogToDebugger(ImGuiTestVerboseLevel level, const char* message);
+    void        LogDebug(const char* fmt, ...)      IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Debug or ImGuiTestVerboseLevel_Trace depending on context depth
+    void        LogInfo(const char* fmt, ...)       IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Info
+    void        LogWarning(const char* fmt, ...)    IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Warning
+    void        LogError(const char* fmt, ...)      IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Error
+    void        LogBasicUiState();
+    void        LogItemList(ImGuiTestItemList* list);
+
+    // Yield, Timing
+    void        Yield(int count = 1);
+    void        YieldUntil(int frame_count);
+    void        Sleep(float time_in_second);            // Sleep for a given simulation time, unless in Fast mode
+    void        SleepShort();                           // Standard short delay of io.ActionDelayShort (~0.15f), unless in Fast mode.
+    void        SleepStandard();                        // Standard regular delay of io.ActionDelayStandard (~0.40f), unless in Fast mode.
+    void        SleepNoSkip(float time_in_second, float framestep_in_second);
+
+    // Base Reference
+    // - ItemClick("Window/Button")                --> click "Window/Button"
+    // - SetRef("Window"), ItemClick("Button")     --> click "Window/Button"
+    // - SetRef("Window"), ItemClick("/Button")    --> click "Window/Button"
+    // - SetRef("Window"), ItemClick("//Button")   --> click "/Button"
+    // - SetRef("//$FOCUSED"), ItemClick("Button") --> click "Button" in focused window.
+    // See https://github.com/ocornut/imgui_test_engine/wiki/Named-References about using ImGuiTestRef in all ImGuiTestContext functions.
+    // Note: SetRef() may take multiple frames to complete if specified ref is an item id.
+    void        SetRef(ImGuiTestRef ref);
+    void        SetRef(ImGuiWindow* window); // Shortcut to SetRef(window->Name) which works for ChildWindow (see code)
+    ImGuiTestRef GetRef();
+
+    // Windows
+    ImGuiTestItemInfo* WindowInfo(ImGuiTestRef window_ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    void        WindowClose(ImGuiTestRef window_ref);
+    void        WindowCollapse(ImGuiTestRef window_ref, bool collapsed);
+    void        WindowFocus(ImGuiTestRef window_ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    void        WindowBringToFront(ImGuiTestRef window_ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    void        WindowMove(ImGuiTestRef window_ref, ImVec2 pos, ImVec2 pivot = ImVec2(0.0f, 0.0f), ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    void        WindowResize(ImGuiTestRef window_ref, ImVec2 sz);
+    bool        WindowTeleportToMakePosVisible(ImGuiTestRef window_ref, ImVec2 pos_in_window);
+    ImGuiWindow*GetWindowByRef(ImGuiTestRef window_ref);
+
+    // Popups
+    void        PopupCloseOne();
+    void        PopupCloseAll();
+    ImGuiID     PopupGetWindowID(ImGuiTestRef ref);
+
+    // Get hash for a decorated ID Path.
+    // Note: for windows you may use WindowInfo()
+    ImGuiID     GetID(ImGuiTestRef ref);
+    ImGuiID     GetID(ImGuiTestRef ref, ImGuiTestRef seed_ref);
+
+    // Miscellaneous helpers
+    ImVec2      GetPosOnVoid(ImGuiViewport* viewport);                              // Find a point that has no windows // FIXME: This needs error return and flag to enable/disable forcefully finding void.
+    ImVec2      GetWindowTitlebarPoint(ImGuiTestRef window_ref);                    // Return a clickable point on window title-bar (window tab for docked windows).
+    ImVec2      GetMainMonitorWorkPos();                                            // Work pos and size of main viewport when viewports are disabled, or work pos and size of monitor containing main viewport when viewports are enabled.
+    ImVec2      GetMainMonitorWorkSize();
+
+    // Screenshot/Video Captures
+    void        CaptureReset();                                                     // Reset state (use when doing multiple captures)
+    void        CaptureSetExtension(const char* ext);                               // Set capture file format (otherwise for video this default to EngineIO->VideoCaptureExtension)
+    bool        CaptureAddWindow(ImGuiTestRef ref);                                 // Add window to be captured (default to capture everything)
+    void        CaptureScreenshotWindow(ImGuiTestRef ref, int capture_flags = 0);   // Trigger a screen capture of a single window (== CaptureAddWindow() + CaptureScreenshot())
+    bool        CaptureScreenshot(int capture_flags = 0);                           // Trigger a screen capture
+    bool        CaptureBeginVideo();                                                // Start a video capture
+    bool        CaptureEndVideo();
+
+    // Mouse inputs
+    void        MouseMove(ImGuiTestRef ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    void        MouseMoveToPos(ImVec2 pos);
+    void        MouseTeleportToPos(ImVec2 pos);
+    void        MouseClick(ImGuiMouseButton button = 0);
+    void        MouseClickMulti(ImGuiMouseButton button, int count);
+    void        MouseDoubleClick(ImGuiMouseButton button = 0);
+    void        MouseDown(ImGuiMouseButton button = 0);
+    void        MouseUp(ImGuiMouseButton button = 0);
+    void        MouseLiftDragThreshold(ImGuiMouseButton button = 0);
+    void        MouseDragWithDelta(ImVec2 delta, ImGuiMouseButton button = 0);
+    void        MouseWheel(ImVec2 delta);
+    void        MouseWheelX(float dx) { MouseWheel(ImVec2(dx, 0.0f)); }
+    void        MouseWheelY(float dy) { MouseWheel(ImVec2(0.0f, dy)); }
+    void        MouseMoveToVoid(ImGuiViewport* viewport = NULL);
+    void        MouseClickOnVoid(ImGuiMouseButton button = 0, ImGuiViewport* viewport = NULL);
+    ImGuiWindow*FindHoveredWindowAtPos(const ImVec2& pos);
+    bool        FindExistingVoidPosOnViewport(ImGuiViewport* viewport, ImVec2* out);
+
+    // Mouse inputs: Viewports
+    // - This is automatically called by SetRef() and any mouse action taking an item reference (e.g. ItemClick("button"), MouseClick("button"))
+    // - But when using raw position directy e.g. MouseMoveToPos() / MouseTeleportToPos() without referring to the parent window before, this needs to be set.
+    void        MouseSetViewport(ImGuiWindow* window);
+    void        MouseSetViewportID(ImGuiID viewport_id);
+
+    // Keyboard inputs
+    void        KeyDown(ImGuiKeyChord key_chord);
+    void        KeyUp(ImGuiKeyChord key_chord);
+    void        KeyPress(ImGuiKeyChord key_chord, int count = 1);
+    void        KeyHold(ImGuiKeyChord key_chord, float time);
+    void        KeySetEx(ImGuiKeyChord key_chord, bool is_down, float time);
+    void        KeyChars(const char* chars);                // Input characters
+    void        KeyCharsAppend(const char* chars);          // Input characters at end of field
+    void        KeyCharsAppendEnter(const char* chars);     // Input characters at end of field, press Enter
+    void        KeyCharsReplace(const char* chars);         // Delete existing field then input characters
+    void        KeyCharsReplaceEnter(const char* chars);    // Delete existing field then input characters, press Enter
+
+    // Navigation inputs
+    // FIXME: Need some redesign/refactoring:
+    // - This was initially intended to: replace mouse action with keyboard/gamepad
+    // - Abstract keyboard vs gamepad actions
+    // However this is widely inconsistent and unfinished at this point.
+    void        SetInputMode(ImGuiInputSource input_mode);  // Mouse or Keyboard or Gamepad. In Keyboard or Gamepad mode, actions such as ItemClick or ItemInput are using nav facilities instead of Mouse.
+    void        NavMoveTo(ImGuiTestRef ref);
+    void        NavActivate();                              // Activate current selected item: activate button, tweak sliders/drags. Equivalent of pressing Space on keyboard, ImGuiKey_GamepadFaceUp on a gamepad.
+    void        NavInput();                                 // Input into select item: input sliders/drags. Equivalent of pressing Enter on keyboard, ImGuiKey_GamepadFaceDown on a gamepad.
+
+    // Scrolling
+    void        ScrollTo(ImGuiTestRef ref, ImGuiAxis axis, float scroll_v, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    void        ScrollToX(ImGuiTestRef ref, float scroll_x) { ScrollTo(ref, ImGuiAxis_X, scroll_x); }
+    void        ScrollToY(ImGuiTestRef ref, float scroll_y) { ScrollTo(ref, ImGuiAxis_Y, scroll_y); }
+    void        ScrollToTop(ImGuiTestRef ref);
+    void        ScrollToBottom(ImGuiTestRef ref);
+    void        ScrollToItem(ImGuiTestRef ref, ImGuiAxis axis, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    void        ScrollToItemX(ImGuiTestRef ref);
+    void        ScrollToItemY(ImGuiTestRef ref);
+    void        ScrollToTabItem(ImGuiTabBar* tab_bar, ImGuiID tab_id);
+    bool        ScrollErrorCheck(ImGuiAxis axis, float expected, float actual, int* remaining_attempts);
+    void        ScrollVerifyScrollMax(ImGuiTestRef ref);
+
+    // Low-level queries
+    // - ItemInfo queries never returns a NULL pointer, instead they return an empty instance (info->IsEmpty(), info->ID == 0) and set contexted as errored.
+    // - You can use ImGuiTestOpFlags_NoError to do a query without marking context as errored. This is what ItemExists() does.
+    ImGuiTestItemInfo*  ItemInfo(ImGuiTestRef ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    ImGuiTestItemInfo*  ItemInfoOpenFullPath(ImGuiTestRef ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
+    ImGuiID             ItemInfoHandleWildcardSearch(const char* wildcard_prefix_start, const char* wildcard_prefix_end, const char* wildcard_suffix_start);
+    ImGuiTestItemInfo*  ItemInfoNull();
+    void                GatherItems(ImGuiTestItemList* out_list, ImGuiTestRef parent, int depth = -1);
+
+    // Item/Widgets manipulation
+    void        ItemAction(ImGuiTestAction action, ImGuiTestRef ref, ImGuiTestOpFlags flags = 0, void* action_arg = NULL);
+    void        ItemClick(ImGuiTestRef ref, ImGuiMouseButton button = 0, ImGuiTestOpFlags flags = 0) { ItemAction(ImGuiTestAction_Click, ref, flags, (void*)(size_t)button); }
+    void        ItemDoubleClick(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)           { ItemAction(ImGuiTestAction_DoubleClick, ref, flags); }
+    void        ItemCheck(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                 { ItemAction(ImGuiTestAction_Check, ref, flags); }
+    void        ItemUncheck(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)               { ItemAction(ImGuiTestAction_Uncheck, ref, flags); }
+    void        ItemOpen(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                  { ItemAction(ImGuiTestAction_Open, ref, flags); }
+    void        ItemClose(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                 { ItemAction(ImGuiTestAction_Close, ref, flags); }
+    void        ItemInput(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                 { ItemAction(ImGuiTestAction_Input, ref, flags); }
+    void        ItemNavActivate(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)           { ItemAction(ImGuiTestAction_NavActivate, ref, flags); }
+    bool        ItemOpenFullPath(ImGuiTestRef);
+
+    // Item/Widgets: Batch actions over an entire scope
+    void        ItemActionAll(ImGuiTestAction action, ImGuiTestRef ref_parent, const ImGuiTestActionFilter* filter = NULL);
+    void        ItemOpenAll(ImGuiTestRef ref_parent, int depth = -1, int passes = -1);
+    void        ItemCloseAll(ImGuiTestRef ref_parent, int depth = -1, int passes = -1);
+
+    // Item/Widgets: Helpers to easily set a value
+    void        ItemInputValue(ImGuiTestRef ref, int v);
+    void        ItemInputValue(ImGuiTestRef ref, float f);
+    void        ItemInputValue(ImGuiTestRef ref, const char* str);
+
+    // Item/Widgets: Drag and Mouse operations
+    void        ItemHold(ImGuiTestRef ref, float time);
+    void        ItemHoldForFrames(ImGuiTestRef ref, int frames);
+    void        ItemDragOverAndHold(ImGuiTestRef ref_src, ImGuiTestRef ref_dst);
+    void        ItemDragAndDrop(ImGuiTestRef ref_src, ImGuiTestRef ref_dst, ImGuiMouseButton button = 0);
+    void        ItemDragWithDelta(ImGuiTestRef ref_src, ImVec2 pos_delta);
+
+    // Item/Widgets: Status query
+    bool        ItemExists(ImGuiTestRef ref);
+    bool        ItemIsChecked(ImGuiTestRef ref);
+    bool        ItemIsOpened(ImGuiTestRef ref);
+    void        ItemVerifyCheckedIfAlive(ImGuiTestRef ref, bool checked);
+
+    // Helpers for Tab Bars widgets
+    void        TabClose(ImGuiTestRef ref);
+    bool        TabBarCompareOrder(ImGuiTabBar* tab_bar, const char** tab_order);
+
+    // Helpers for MenuBar and Menus widgets
+    // - e.g. MenuCheck("File/Options/Enable grid");
+    void        MenuAction(ImGuiTestAction action, ImGuiTestRef ref);
+    void        MenuActionAll(ImGuiTestAction action, ImGuiTestRef ref_parent);
+    void        MenuClick(ImGuiTestRef ref)                 { MenuAction(ImGuiTestAction_Click, ref); }
+    void        MenuCheck(ImGuiTestRef ref)                 { MenuAction(ImGuiTestAction_Check, ref); }
+    void        MenuUncheck(ImGuiTestRef ref)               { MenuAction(ImGuiTestAction_Uncheck, ref); }
+    void        MenuCheckAll(ImGuiTestRef ref_parent)       { MenuActionAll(ImGuiTestAction_Check, ref_parent); }
+    void        MenuUncheckAll(ImGuiTestRef ref_parent)     { MenuActionAll(ImGuiTestAction_Uncheck, ref_parent); }
+
+    // Helpers for Combo Boxes
+    void        ComboClick(ImGuiTestRef ref);
+    void        ComboClickAll(ImGuiTestRef ref);
+
+    // Helpers for Tables
+    void                        TableOpenContextMenu(ImGuiTestRef ref, int column_n = -1);
+    ImGuiSortDirection          TableClickHeader(ImGuiTestRef ref, const char* label, ImGuiKeyChord key_mods = 0);
+    void                        TableSetColumnEnabled(ImGuiTestRef ref, const char* label, bool enabled);
+    void                        TableResizeColumn(ImGuiTestRef ref, int column_n, float width);
+    const ImGuiTableSortSpecs*  TableGetSortSpecs(ImGuiTestRef ref);
+
+    // Viewports
+    // IMPORTANT: Those function may alter Platform state (unless using the "Mock Viewport" backend). Use carefully.
+    // Those are mostly useful to simulate OS actions and testing of viewport-specific features, may not be useful to most users.
+#ifdef IMGUI_HAS_VIEWPORT
+    //void      ViewportPlatform_SetWindowPos(ImGuiViewport* viewport, const ImVec2& pos);
+    //void      ViewportPlatform_SetWindowSize(ImGuiViewport* viewport, const ImVec2& size);
+    void        ViewportPlatform_SetWindowFocus(ImGuiViewport* viewport);
+    void        ViewportPlatform_CloseWindow(ImGuiViewport* viewport);
+#endif
+
+    // Docking
+#ifdef IMGUI_HAS_DOCK
+    void        DockClear(const char* window_name, ...);
+    void        DockInto(ImGuiTestRef src_id, ImGuiTestRef dst_id, ImGuiDir split_dir = ImGuiDir_None, bool is_outer_docking = false, ImGuiTestOpFlags flags = 0);
+    void        UndockNode(ImGuiID dock_id);
+    void        UndockWindow(const char* window_name);
+    bool        WindowIsUndockedOrStandalone(ImGuiWindow* window);
+    bool        DockIdIsUndockedOrStandalone(ImGuiID dock_id);
+    void        DockNodeHideTabBar(ImGuiDockNode* node, bool hidden);
+#endif
+
+    // Performances Measurement (use along with Dear ImGui Perf Tool)
+    void        PerfCalcRef();
+    void        PerfCapture(const char* category = NULL, const char* test_name = NULL, const char* csv_file = NULL);
+
+    // Obsolete functions
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    // Obsoleted 2022/10/11
+    ImGuiID     GetIDByInt(int n);                                      // Prefer using "$$123"
+    ImGuiID     GetIDByInt(int n, ImGuiTestRef seed_ref);
+    ImGuiID     GetIDByPtr(void* p);                                    // Prefer using "$$(ptr)0xFFFFFFFF"
+    ImGuiID     GetIDByPtr(void* p, ImGuiTestRef seed_ref);
+    // Obsoleted 2022/09/26
+    void        KeyModDown(ImGuiModFlags mods)  { KeyDown(mods); }
+    void        KeyModUp(ImGuiModFlags mods)    { KeyUp(mods); }
+    void        KeyModPress(ImGuiModFlags mods) { KeyPress(mods); }
+#endif
+
+    // [Internal]
+    // FIXME: Aim to remove this system...
+    void        ForeignWindowsHideOverPos(ImVec2 pos, ImGuiWindow** ignore_list);
+    void        ForeignWindowsUnhideAll();
+};
+
+//-------------------------------------------------------------------------
+// [SECTION] Debugging macros (IM_SUSPEND_TESTFUNC)
+//-------------------------------------------------------------------------
+
+// Debug: Temporarily suspend TestFunc to let user interactively inspect the GUI state (user will need to press the "Continue" button to resume TestFunc execution)
+#define IM_SUSPEND_TESTFUNC()               do { if (ctx->SuspendTestFunc(__FILE__, __LINE__)) return; } while (0)
+
+//-------------------------------------------------------------------------
+// [SECTION] Testing/Checking macros: IM_CHECK(), IM_ERRORF() etc.
+//-------------------------------------------------------------------------
+
+// Helpers used by IM_CHECK_OP() macros.
+// ImGuiTestEngine_GetTempStringBuilder() returns a shared instance of ImGuiTextBuffer to recycle memory allocations
+template<typename T> void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, T v) { buf->append("???"); IM_UNUSED(v); } // FIXME-TESTS: Could improve with some template magic
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, const char* v) { buf->appendf("\"%s\"", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, bool v)        { buf->append(v ? "true" : "false"); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS8 v)        { buf->appendf("%d", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU8 v)        { buf->appendf("%u", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS16 v)       { buf->appendf("%hd", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU16 v)       { buf->appendf("%hu", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS32 v)       { buf->appendf("%d", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU32 v)       { buf->appendf("0x%08X", v); } // Assuming ImGuiID
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS64 v)       { buf->appendf("%lld", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU64 v)       { buf->appendf("%llu", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, float v)       { buf->appendf("%.3f", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, double v)      { buf->appendf("%f", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImVec2 v)      { buf->appendf("(%.3f, %.3f)", v.x, v.y); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, const void* v) { buf->appendf("%p", v); }
+template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImGuiWindow* v){ if (v) buf->appendf("\"%s\"", v->Name); else buf->append("NULL"); }
+
+// We embed every macro in a do {} while(0) statement as a trick to allow using them as regular single statement, e.g. if (XXX) IM_CHECK(A); else IM_CHECK(B)
+// We leave the IM_DEBUG_BREAK() outside of the check function to step out faster when using a debugger. It also has the benefit of being lighter than an IM_ASSERT().
+#define IM_CHECK(_EXPR)                     do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, res, #_EXPR))          { IM_DEBUG_BREAK(); } if (!res) return; } while (0)
+#define IM_CHECK_NO_RET(_EXPR)              do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, res, #_EXPR))          { IM_DEBUG_BREAK(); } } while (0)
+#define IM_CHECK_SILENT(_EXPR)              do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_SilentSuccess, res, #_EXPR)) { IM_DEBUG_BREAK(); } if (!res) return; } while (0)
+#define IM_CHECK_RETV(_EXPR,_RETV)          do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, res, #_EXPR))          { IM_DEBUG_BREAK(); } if (!res) return _RETV; } while (0)
+#define IM_CHECK_SILENT_RETV(_EXPR,_RETV)   do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_SilentSuccess, res, #_EXPR)) { IM_DEBUG_BREAK(); } if (!res) return _RETV; } while (0)
+#define IM_ERRORF(_FMT,...)                 do { if (ImGuiTestEngine_Error(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, _FMT, __VA_ARGS__))                              { IM_DEBUG_BREAK(); } } while (0)
+#define IM_ERRORF_NOHDR(_FMT,...)           do { if (ImGuiTestEngine_Error(NULL, NULL, 0, ImGuiTestCheckFlags_None, _FMT, __VA_ARGS__))                                             { IM_DEBUG_BREAK(); } } while (0)
+
+// Those macros allow us to print out the values of both LHS and RHS expressions involved in a check.
+#define IM_CHECK_OP(_LHS, _RHS, _OP, _RETURN)                   \
+    do                                                          \
+    {                                                           \
+        auto __lhs = _LHS;  /* Cache to avoid side effects */   \
+        auto __rhs = _RHS;                                      \
+        bool __res = __lhs _OP __rhs;                           \
+        ImGuiTextBuffer* expr_buf = ImGuiTestEngine_GetTempStringBuilder(); \
+        expr_buf->append(#_LHS " [");                           \
+        ImGuiTestEngineUtil_appendf_auto(expr_buf, __lhs);      \
+        expr_buf->append("] " #_OP " " #_RHS " [");             \
+        ImGuiTestEngineUtil_appendf_auto(expr_buf, __rhs);      \
+        expr_buf->append("]");                                  \
+        if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, __res, expr_buf->c_str())) \
+            IM_ASSERT(__res);                                   \
+        if (_RETURN && !__res)                                  \
+            return;                                             \
+    } while (0)
+
+#define IM_CHECK_STR_OP(_LHS, _RHS, _OP, _RETURN, _FLAGS)       \
+    do                                                          \
+    {                                                           \
+        bool __res;                                             \
+        if (ImGuiTestEngine_CheckStrOp(__FILE__, __func__, __LINE__, _FLAGS, #_OP, #_LHS, _LHS, #_RHS, _RHS, &__res)) \
+            IM_ASSERT(__res);                                   \
+        if (_RETURN && !__res)                                  \
+            return;                                             \
+    } while (0)
+
+// Scalar compares
+#define IM_CHECK_EQ(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, ==, true)   // Equal
+#define IM_CHECK_NE(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, !=, true)   // Not Equal
+#define IM_CHECK_LT(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, < , true)   // Less Than
+#define IM_CHECK_LE(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, <=, true)   // Less or Equal
+#define IM_CHECK_GT(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, > , true)   // Greater Than
+#define IM_CHECK_GE(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, >=, true)   // Greater or Equal
+
+// Scalar compares, without return on failure
+#define IM_CHECK_EQ_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, ==, false)  // Equal
+#define IM_CHECK_NE_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, !=, false)  // Not Equal
+#define IM_CHECK_LT_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, < , false)  // Less Than
+#define IM_CHECK_LE_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, <=, false)  // Less or Equal
+#define IM_CHECK_GT_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, > , false)  // Greater Than
+#define IM_CHECK_GE_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, >=, false)  // Greater or Equal
+
+// String compares
+#define IM_CHECK_STR_EQ(_LHS, _RHS)                 IM_CHECK_STR_OP(_LHS, _RHS, ==, true, ImGuiTestCheckFlags_None)
+#define IM_CHECK_STR_NE(_LHS, _RHS)                 IM_CHECK_STR_OP(_LHS, _RHS, !=, true, ImGuiTestCheckFlags_None)
+#define IM_CHECK_STR_EQ_NO_RET(_LHS, _RHS)          IM_CHECK_STR_OP(_LHS, _RHS, ==, false, ImGuiTestCheckFlags_None)
+#define IM_CHECK_STR_NE_NO_RET(_LHS, _RHS)          IM_CHECK_STR_OP(_LHS, _RHS, !=, false, ImGuiTestCheckFlags_None)
+#define IM_CHECK_STR_EQ_SILENT(_LHS, _RHS)          IM_CHECK_STR_OP(_LHS, _RHS, ==, true, ImGuiTestCheckFlags_SilentSuccess)
+
+// Floating point compares
+#define IM_CHECK_FLOAT_EQ_EPS(_LHS, _RHS)           IM_CHECK_LE(ImFabs(_LHS - (_RHS)), FLT_EPSILON)   // Float Equal
+#define IM_CHECK_FLOAT_NEAR(_LHS, _RHS, _EPS)       IM_CHECK_LE(ImFabs(_LHS - (_RHS)), _EPS)
+#define IM_CHECK_FLOAT_NEAR_NO_RET(_LHS, _RHS, _E)  IM_CHECK_LE_NO_RET(ImFabs(_LHS - (_RHS)), _E)
+
+//-------------------------------------------------------------------------
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif