pwmgr

// (demo code)

// Help:

// - Need help integrating Dear ImGui in your codebase?

// - Read Getting Started https://github.com/ocornut/imgui/wiki/Getting-Started

// - Read 'Programmer guide' in imgui.cpp for notes on how to setup Dear ImGui in your codebase.

// Get the latest version at https://github.com/ocornut/imgui

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

// PLEASE DO NOT REMOVE THIS FILE FROM YOUR PROJECT!

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

// Because we can't assume anything about your support of maths operators, we cannot use them in imgui_demo.cpp.

// Navigating this file:

/*

// [SECTION] Forward Declarations

// [SECTION] Helpers

// [SECTION] Demo Window / ShowDemoWindow()

// [SECTION] About Window / ShowAboutWindow()

// [SECTION] Style Editor / ShowStyleEditor()

// [SECTION] User Guide / ShowUserGuide()

// [SECTION] Example App: Manipulating window titles / ShowExampleAppWindowTitles()

// [SECTION] Example App: Custom Rendering using ImDrawList API / ShowExampleAppCustomRendering()

// [SECTION] Example App: Documents Handling / ShowExampleAppDocuments()

*/

#if !defined(_MSC_VER) || _MSC_VER >= 1800

#include <inttypes.h> // PRId64/PRIu64, not avail in some MinGW headers.

#endif

// Visual Studio warnings

#ifdef _MSC_VER

#pragma clang diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function // using printf() is a misery with this as C++ va_arg ellipsis changes float to double.

#pragma clang diagnostic ignored "-Wreserved-id-macro" // warning: macro name is a reserved identifier

#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision

#elif defined(__GNUC__)

#endif

// Play it nice with Windows users (Update: May 2018, Notepad now supports Unix-style carriage returns!)

#endif

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

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

#if !defined(IMGUI_DISABLE_DEMO_WINDOWS)

// Forward Declarations

static void ShowExampleAppMainMenuBar();

static void ShowExampleAppConsole(bool* p_open);

static void ShowExampleAppCustomRendering(bool* p_open);

static void ShowExampleAppDocuments(bool* p_open);

static void ShowExampleAppLog(bool* p_open);

static void ShowExampleAppLayout(bool* p_open);

static void ShowExampleAppSimpleOverlay(bool* p_open);

static void ShowExampleAppAutoResize(bool* p_open);

static void ShowExampleAppConstrainedResize(bool* p_open);

static void ShowExampleMenuFile();

// We split the contents of the big ShowDemoWindow() function into smaller functions

static void ShowDemoWindowLayout();

static void ShowDemoWindowPopups();

static void ShowDemoWindowTables();

#define IMGUI_DEMO_MARKER(section) do { if (GImGuiDemoMarkerCallback != NULL) GImGuiDemoMarkerCallback(__FILE__, __LINE__, section, GImGuiDemoMarkerCallbackUserData); } while (0)

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

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

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

// Demonstrate most Dear ImGui features (this is big function!)

// You may execute this function to experiment with the UI and understand what it does.

// You may then search for keywords in the code when you are interested by a specific feature.

// Most functions would normally just assert/crash if the context is missing.

IM_ASSERT(ImGui::GetCurrentContext() != NULL && "Missing Dear ImGui context. Refer to examples app!");

// Examples Apps (accessible from the "Examples" menu)

// Dear ImGui Tools (accessible from the "Tools" menu)

ImGui::ShowStyleEditor();

ImGui::End();

}

// Demonstrate the various window flags. Typically you would just use the default!

static bool no_titlebar = false;

}

// Most "big" widgets share a common width settings by default. See 'Demo->Layout->Widgets Width' for details.

// Menu Bar

ImGui::Text("dear imgui says hello! (%s) (%d)", IMGUI_VERSION, IMGUI_VERSION_NUM);

ImGui::Spacing();

ImGui::BulletText("See the ShowDemoWindow() code in imgui_demo.cpp. <- you are here!");

ImGui::BulletText("See comments in imgui.cpp.");

ImGui::BulletText("See example applications in the examples/ folder.");

ImGui::BulletText("Set 'io.ConfigFlags |= NavEnableKeyboard' for keyboard controls.");

ImGui::BulletText("Set 'io.ConfigFlags |= NavEnableGamepad' for gamepad controls.");

ImGui::SameLine(); HelpMarker("Enable keyboard controls.");

ImGui::CheckboxFlags("io.ConfigFlags: NavEnableGamepad", &io.ConfigFlags, ImGuiConfigFlags_NavEnableGamepad);

ImGui::SameLine(); HelpMarker("Enable gamepad controls. Require backend to set io.BackendFlags |= ImGuiBackendFlags_HasGamepad.\n\nRead instructions in imgui.cpp for details.");

ImGui::CheckboxFlags("io.ConfigFlags: NoMouse", &io.ConfigFlags, ImGuiConfigFlags_NoMouse);

if (io.ConfigFlags & ImGuiConfigFlags_NoMouse)

{

if (fmodf((float)ImGui::GetTime(), 0.40f) < 0.20f)

{

ImGui::SameLine();

ImGui::Text("<<PRESS SPACE TO DISABLE>>");

}

io.ConfigFlags &= ~ImGuiConfigFlags_NoMouse;

}

ImGui::SameLine(); HelpMarker("Instruct backend to not alter mouse cursor shape and visibility.");

ImGui::Checkbox("io.ConfigInputTrickleEventQueue", &io.ConfigInputTrickleEventQueue);

ImGui::SameLine(); HelpMarker("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.");

ImGui::Checkbox("io.MouseDrawCursor", &io.MouseDrawCursor);

ImGui::SameLine(); HelpMarker("Instruct Dear ImGui to render a mouse cursor itself. Note that a mouse cursor rendered via your application GPU rendering path will feel more laggy than hardware cursor, but will be more in sync with your other visuals.\n\nSome desktop applications may use both kinds of cursors (e.g. enable software cursor only when resizing/dragging something).");

ImGui::SeparatorText("Widgets");

ImGui::Checkbox("io.ConfigInputTextCursorBlink", &io.ConfigInputTextCursorBlink);

ImGui::SameLine(); HelpMarker("Enable blinking cursor (optional as some users consider it to be distracting).");

ImGui::SameLine(); HelpMarker("Pressing Enter will keep item active and select contents (single-line only).");

ImGui::Checkbox("io.ConfigDragClickToInputText", &io.ConfigDragClickToInputText);

ImGui::SameLine(); HelpMarker("Enable turning DragXXX widgets into text input with a simple mouse click-release (without moving).");

ImGui::Checkbox("io.ConfigMacOSXBehaviors", &io.ConfigMacOSXBehaviors);

ImGui::Text("Also see Style->Rendering for rendering options.");

ImGui::SeparatorText("Debug");

ImGui::Checkbox("io.ConfigDebugIsDebuggerPresent", &io.ConfigDebugIsDebuggerPresent);

ImGui::SameLine(); HelpMarker("Enable various tools calling IM_DEBUG_BREAK().\n\nRequires a debugger being attached, otherwise IM_DEBUG_BREAK() options will appear to crash your application.");

ImGui::BeginDisabled();

ImGui::EndDisabled();

ImGui::SameLine(); HelpMarker("First calls to Begin()/BeginChild() will return false.\n\nTHIS OPTION IS DISABLED because it needs to be set at application boot-time to make sense. Showing the disabled option is a way to make this feature easier to discover.");

ImGui::Checkbox("io.ConfigDebugBeginReturnValueLoop", &io.ConfigDebugBeginReturnValueLoop);

ImGui::CheckboxFlags("io.BackendFlags: HasSetMousePos", &io.BackendFlags, ImGuiBackendFlags_HasSetMousePos);

ImGui::CheckboxFlags("io.BackendFlags: RendererHasVtxOffset", &io.BackendFlags, ImGuiBackendFlags_RendererHasVtxOffset);

ImGui::EndDisabled();

ImGui::TreePop();

ImGui::Spacing();

}

IMGUI_DEMO_MARKER("Configuration/Style");

if (ImGui::TreeNode("Style"))

{

HelpMarker("The same contents can be accessed in 'Tools->Style Editor' or by calling the ShowStyleEditor() function.");

ImGui::TreePop();

ImGui::Spacing();

}

}

// All demo contents

ShowDemoWindowLayout();

ShowDemoWindowPopups();

ShowDemoWindowTables();

ImGui::End();

}

{

IMGUI_DEMO_MARKER("Widgets");

if (!ImGui::CollapsingHeader("Widgets"))

return;

IMGUI_DEMO_MARKER("Widgets/Basic/Buttons (Repeating)");

static int counter = 0;

float spacing = ImGui::GetStyle().ItemInnerSpacing.x;

if (ImGui::ArrowButton("##left", ImGuiDir_Left)) { counter--; }

ImGui::SameLine(0.0f, spacing);

if (ImGui::ArrowButton("##right", ImGuiDir_Right)) { counter++; }

ImGui::SameLine();

ImGui::Text("%d", counter);

{

IMGUI_DEMO_MARKER("Widgets/Basic/DragInt, DragFloat");

ImGui::DragInt("drag int", &i1, 1);

ImGui::SameLine(); HelpMarker(

"Click and drag to edit value.\n"

"Hold SHIFT/ALT for faster/slower edit.\n"

"Double-click or CTRL+click to input value.");

ImGui::DragInt("drag int 0..100", &i2, 1, 0, 100, "%d%%", ImGuiSliderFlags_AlwaysClamp);

static float f1 = 1.00f, f2 = 0.0067f;

ImGui::DragFloat("drag float", &f1, 0.005f);

ImGui::DragFloat("drag small float", &f2, 0.0001f, 0.0f, 0.0f, "%.06f ns");

}

ImGui::SeparatorText("Sliders");

// The following examples are passed for documentation purpose but may not be useful to most users.

// Passing ImGuiHoveredFlags_ForTooltip to IsItemHovered() will pull ImGuiHoveredFlags flags values from

// With default settings, ImGuiHoveredFlags_ForTooltip is equivalent to ImGuiHoveredFlags_DelayShort + ImGuiHoveredFlags_Stationary.

ImGui::Button("Manual", sz);

if (ImGui::IsItemHovered(ImGuiHoveredFlags_ForTooltip))

// Using ImGuiHoveredFlags_ForTooltip will pull flags from 'style.HoverFlagsForTooltipMouse' or 'style.HoverFlagsForTooltipNav',

// which default value include the ImGuiHoveredFlags_AllowWhenDisabled flag.

ImGui::BeginDisabled();

ImGui::Button("Disabled item", sz);

if (ImGui::IsItemHovered(ImGuiHoveredFlags_ForTooltip))

ImGui::SetTooltip("I am a a tooltip for a disabled item.");

ImGui::TreePop();

}

if (i == 0)

ImGui::SetNextItemOpen(true, ImGuiCond_Once);

{

ImGui::Text("blah blah");

ImGui::SameLine();

if (ImGui::SmallButton("button")) {}

ImGui::TreePop();

}

}

ImGui::TreePop();

}

ImGui::CheckboxFlags("ImGuiTreeNodeFlags_OpenOnDoubleClick", &base_flags, ImGuiTreeNodeFlags_OpenOnDoubleClick);

ImGui::CheckboxFlags("ImGuiTreeNodeFlags_SpanAvailWidth", &base_flags, ImGuiTreeNodeFlags_SpanAvailWidth); ImGui::SameLine(); HelpMarker("Extend hit area to all available width instead of allowing more items to be laid out after the node.");

ImGui::CheckboxFlags("ImGuiTreeNodeFlags_SpanFullWidth", &base_flags, ImGuiTreeNodeFlags_SpanFullWidth);

ImGui::CheckboxFlags("ImGuiTreeNodeFlags_SpanAllColumns", &base_flags, ImGuiTreeNodeFlags_SpanAllColumns); ImGui::SameLine(); HelpMarker("For use in Tables only.");

ImGui::Checkbox("Align label with current X position", &align_label_with_current_x_position);

ImGui::Checkbox("Test tree node as drag source", &test_drag_and_drop);

ImGui::Text("Hello!");

ImGui::Text("This is a drag and drop source");

ImGui::EndDragDropSource();

}

if (node_open)

{

ImGui::BulletText("Blah blah\nBlah Blah");

ImGui::TreePop();

}

}

// (your selection data could be an index, a pointer to the object, an id for the object, a flag intrusively

// stored in the object itself, etc.)

const char* items[] = { "AAAA", "BBBB", "CCCC", "DDDD", "EEEE", "FFFF", "GGGG", "HHHH", "IIII", "JJJJ", "KKKK", "LLLLLLL", "MMMM", "OOOOOOO" };

// Pass in the preview value visible before opening the combo (it could technically be different contents or not pulled from items[])

if (ImGui::BeginCombo("combo 1", combo_preview_value, flags))

{

for (int n = 0; n < IM_ARRAYSIZE(items); n++)

{

if (ImGui::Selectable(items[n], is_selected))

// Set the initial focus when opening the combo (scrolling + keyboard navigation focus)

if (is_selected)

// (your selection data could be an index, a pointer to the object, an id for the object, a flag intrusively

// stored in the object itself, etc.)

const char* items[] = { "AAAA", "BBBB", "CCCC", "DDDD", "EEEE", "FFFF", "GGGG", "HHHH", "IIII", "JJJJ", "KKKK", "LLLLLLL", "MMMM", "OOOOOOO" };

if (ImGui::BeginListBox("listbox 1"))

{

for (int n = 0; n < IM_ARRAYSIZE(items); n++)

{

if (ImGui::Selectable(items[n], is_selected))

// Set the initial focus when opening the combo (scrolling + keyboard navigation focus)

if (is_selected)

}

ImGui::EndListBox();

}

// Custom size: use all width, 5 items tall

ImGui::Text("Full-width:");

{

for (int n = 0; n < IM_ARRAYSIZE(items); n++)

{

// Set the initial focus when opening the combo (scrolling + keyboard navigation focus)

if (is_selected)

}

IMGUI_DEMO_MARKER("Widgets/Selectables");

if (ImGui::TreeNode("Selectables"))

{

// Selectable() has 2 overloads:

ImGui::TreePop();

}

IMGUI_DEMO_MARKER("Widgets/Selectables/Rendering more items on the same line");

if (ImGui::TreeNode("Rendering more items on the same line"))

{

ImGui::TreePop();

}

{

static bool selected[10] = {};

ImGui::TreePop();

}

// To wire InputText() with std::string or any other custom string type,

// see the "Text Input > Resize Callback" section of this demo, and the misc/cpp/imgui_stdlib.h file.

IMGUI_DEMO_MARKER("Widgets/Text Input");

ImGui::CheckboxFlags("ImGuiTabBarFlags_AutoSelectNewTabs", &tab_bar_flags, ImGuiTabBarFlags_AutoSelectNewTabs);

ImGui::CheckboxFlags("ImGuiTabBarFlags_TabListPopupButton", &tab_bar_flags, ImGuiTabBarFlags_TabListPopupButton);

ImGui::CheckboxFlags("ImGuiTabBarFlags_NoCloseWithMiddleMouseButton", &tab_bar_flags, ImGuiTabBarFlags_NoCloseWithMiddleMouseButton);

if ((tab_bar_flags & ImGuiTabBarFlags_FittingPolicyMask_) == 0)

tab_bar_flags |= ImGuiTabBarFlags_FittingPolicyDefault_;

if (ImGui::CheckboxFlags("ImGuiTabBarFlags_FittingPolicyResizeDown", &tab_bar_flags, ImGuiTabBarFlags_FittingPolicyResizeDown))

tab_bar_flags &= ~(ImGuiTabBarFlags_FittingPolicyMask_ ^ ImGuiTabBarFlags_FittingPolicyScroll);

// Tab Bar

const char* names[4] = { "Artichoke", "Beetroot", "Celery", "Daikon" };

static bool opened[4] = { true, true, true, true }; // Persistent user state

for (int n = 0; n < IM_ARRAYSIZE(opened); n++)

{

ImGui::Checkbox(names[n], &opened[n]);

}

ImGui::Checkbox("Animate", &animate);

// Plot as lines and plot as histogram

static float arr[] = { 0.6f, 0.1f, 1.0f, 0.5f, 0.92f, 0.1f, 0.2f };

ImGui::PlotLines("Frame Times", arr, IM_ARRAYSIZE(arr));

ImGui::PlotHistogram("Histogram", arr, IM_ARRAYSIZE(arr), 0, NULL, 0.0f, 1.0f, ImVec2(0, 80.0f));

// Fill an array of contiguous float values to plot

// Tip: If your float aren't contiguous but part of a structure, you can pass a pointer to your first float

ImGui::SameLine();

ImGui::SliderInt("Sample count", &display_count, 1, 400);

float (*func)(void*, int) = (func_type == 0) ? Funcs::Sin : Funcs::Saw;

ImGui::Separator();

// Animate a simple progress bar

static float progress = 0.0f, progress_dir = 1.0f;

// Typically we would use ImVec2(-1.0f,0.0f) or ImVec2(-FLT_MIN,0.0f) to use all available width,

// or ImVec2(width,0.0f) for a specified width. ImVec2(0.0f,0.0f) uses ItemWidth.

char buf[32];

sprintf(buf, "%d/%d", (int)(progress_saturated * 1753), 1753);

ImGui::ProgressBar(progress, ImVec2(0.f, 0.f), buf);

ImGui::TreePop();

}

// Demonstrate using advanced flags for DragXXX and SliderXXX functions. Note that the flags are the same!

static ImGuiSliderFlags flags = ImGuiSliderFlags_None;

ImGui::CheckboxFlags("ImGuiSliderFlags_AlwaysClamp", &flags, ImGuiSliderFlags_AlwaysClamp);

ImGui::CheckboxFlags("ImGuiSliderFlags_Logarithmic", &flags, ImGuiSliderFlags_Logarithmic);

ImGui::SameLine(); HelpMarker("Enable logarithmic editing (more precision for small values).");

ImGui::CheckboxFlags("ImGuiSliderFlags_NoRoundToFormat", &flags, ImGuiSliderFlags_NoRoundToFormat);

ImGui::SameLine(); HelpMarker("Disable rounding underlying value to match precision of the format string (e.g. %.3f values are rounded to those 3 digits).");

ImGui::CheckboxFlags("ImGuiSliderFlags_NoInput", &flags, ImGuiSliderFlags_NoInput);

ImGui::SameLine(); HelpMarker("Disable CTRL+Click or Enter key allowing to input text directly into the widget.");

// Drags

static float drag_f = 0.5f;

ImGui::DragFloat("DragFloat (0 -> +inf)", &drag_f, 0.005f, 0.0f, FLT_MAX, "%.3f", flags);

ImGui::DragFloat("DragFloat (-inf -> 1)", &drag_f, 0.005f, -FLT_MAX, 1.0f, "%.3f", flags);

ImGui::DragFloat("DragFloat (-inf -> +inf)", &drag_f, 0.005f, -FLT_MAX, +FLT_MAX, "%.3f", flags);

ImGui::DragInt("DragInt (0 -> 100)", &drag_i, 0.5f, 0, 100, "%d", flags);

// Sliders

static float slider_f = 0.5f;

static int slider_i = 50;

ImGui::Text("Underlying float value: %f", slider_f);

ImGui::TreePop();

}

IMGUI_DEMO_MARKER("Widgets/Data Types/Inputs");

static bool inputs_step = true;

ImGui::SeparatorText("Inputs");

ImGui::Checkbox("Show step buttons", &inputs_step);

ImGui::TreePop();

}

IMGUI_DEMO_MARKER("Widgets/Drag and Drop/Drag to reorder items (simple)");

if (ImGui::TreeNode("Drag to reorder items (simple)"))

{

// Simple reordering

HelpMarker(

"We don't use the drag and drop api at all here! "

}

}

}

ImGui::TreePop();

}

{

IM_UNUSED(payload);

ImGui::SetMouseCursor(ImGuiMouseCursor_NotAllowed);

}

ImGui::EndDragDropTarget();

}

ImGui::BeginDisabled(true);

if (item_type == 0) { ImGui::Text("ITEM: Text"); } // Testing text items with no identifier/interaction

if (item_type == 1) { ret = ImGui::Button("ITEM: Button"); } // Testing button

if (item_type == 3) { ret = ImGui::Checkbox("ITEM: Checkbox", &b); } // Testing checkbox

if (item_type == 4) { ret = ImGui::SliderFloat("ITEM: SliderFloat", &col4f[0], 0.0f, 1.0f); } // Testing basic item

if (item_type == 5) { ret = ImGui::InputText("ITEM: InputText", &str[0], IM_ARRAYSIZE(str)); } // Testing input text (which handles tabbing)

static bool embed_all_inside_a_child_window = false;

ImGui::Checkbox("Embed everything inside a child window for testing _RootWindow flag.", &embed_all_inside_a_child_window);

if (embed_all_inside_a_child_window)

// Testing IsWindowFocused() function with its various flags.

ImGui::BulletText(

ImGui::IsWindowHovered(ImGuiHoveredFlags_AnyWindow),

ImGui::IsWindowHovered(ImGuiHoveredFlags_Stationary));

ImGui::Text("This is another child window for testing the _ChildWindows flag.");

ImGui::EndChild();

if (embed_all_inside_a_child_window)

}

}

{

{

{

}

{

{

{

}

{

}