{

ImGui::TextDisabled("(?)");

if (ImGui::IsItemHovered())

{

ImGui::BeginTooltip();

ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);

ImGui::TextUnformatted(desc);

ImGui::PopTextWrapPos();

ImGui::EndTooltip();

}

{

ImGuiIO& io = ImGui::GetIO();

ImGui::BulletText("Double-click on title bar to collapse window.");

ImGui::BulletText(

"Click and drag on lower corner to resize window\n"

"(double-click to auto fit window to its contents).");

ImGui::BulletText("CTRL+Click on a slider or drag box to input value as text.");

ImGui::BulletText("TAB/SHIFT+TAB to cycle through keyboard editable fields.");

if (io.FontAllowUserScaling)

ImGui::BulletText("CTRL+Mouse Wheel to zoom window contents.");

ImGui::BulletText("While inputing text:\n");

ImGui::Indent();

ImGui::BulletText("CTRL+Left/Right to word jump.");

ImGui::BulletText("CTRL+A or double-click to select all.");

ImGui::BulletText("CTRL+X/C/V to use clipboard cut/copy/paste.");

ImGui::BulletText("CTRL+Z,CTRL+Y to undo/redo.");

ImGui::BulletText("ESCAPE to revert.");

ImGui::BulletText("You can apply arithmetic operators +,*,/ on numerical values.\nUse +- to subtract.");

ImGui::Unindent();

ImGui::BulletText("With keyboard navigation enabled:");

ImGui::Indent();

ImGui::BulletText("Arrow keys to navigate.");

ImGui::BulletText("Space to activate a widget.");

ImGui::BulletText("Return to input text into a widget.");

ImGui::BulletText("Escape to deactivate a widget, close popup, exit child window.");

ImGui::BulletText("Alt to jump to the menu layer of a window.");

ImGui::BulletText("CTRL+Tab to select a window.");

ImGui::Unindent();

{

// Exceptionally add an extra assert here for people confused about initial Dear ImGui setup

// Most ImGui functions would normally just 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)

static bool show_app_main_menu_bar = false;

static bool show_app_documents = false;

static bool show_app_console = false;

static bool show_app_log = false;

static bool show_app_layout = false;

static bool show_app_property_editor = false;

static bool show_app_long_text = false;

static bool show_app_auto_resize = false;

static bool show_app_constrained_resize = false;

static bool show_app_simple_overlay = false;

static bool show_app_window_titles = false;

static bool show_app_custom_rendering = false;

if (show_app_main_menu_bar) ShowExampleAppMainMenuBar();

if (show_app_documents) ShowExampleAppDocuments(&show_app_documents);

if (show_app_console) ShowExampleAppConsole(&show_app_console);

if (show_app_log) ShowExampleAppLog(&show_app_log);

if (show_app_layout) ShowExampleAppLayout(&show_app_layout);

if (show_app_property_editor) ShowExampleAppPropertyEditor(&show_app_property_editor);

if (show_app_long_text) ShowExampleAppLongText(&show_app_long_text);

if (show_app_auto_resize) ShowExampleAppAutoResize(&show_app_auto_resize);

if (show_app_constrained_resize) ShowExampleAppConstrainedResize(&show_app_constrained_resize);

if (show_app_simple_overlay) ShowExampleAppSimpleOverlay(&show_app_simple_overlay);

if (show_app_window_titles) ShowExampleAppWindowTitles(&show_app_window_titles);

if (show_app_custom_rendering) ShowExampleAppCustomRendering(&show_app_custom_rendering);

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

static bool show_app_metrics = false;

static bool show_app_style_editor = false;

static bool show_app_about = false;

if (show_app_metrics) { ImGui::ShowMetricsWindow(&show_app_metrics); }

if (show_app_about) { ImGui::ShowAboutWindow(&show_app_about); }

if (show_app_style_editor)

{

ImGui::Begin("Dear ImGui Style Editor", &show_app_style_editor);

ImGui::ShowStyleEditor();

ImGui::End();

}

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

static bool no_titlebar = false;

static bool no_scrollbar = false;

static bool no_menu = false;

static bool no_move = false;

static bool no_resize = false;

static bool no_collapse = false;

static bool no_close = false;

static bool no_nav = false;

static bool no_background = false;

static bool no_bring_to_front = false;

ImGuiWindowFlags window_flags = 0;

if (no_titlebar) window_flags |= ImGuiWindowFlags_NoTitleBar;

if (no_scrollbar) window_flags |= ImGuiWindowFlags_NoScrollbar;

if (!no_menu) window_flags |= ImGuiWindowFlags_MenuBar;

if (no_move) window_flags |= ImGuiWindowFlags_NoMove;

if (no_resize) window_flags |= ImGuiWindowFlags_NoResize;

if (no_collapse) window_flags |= ImGuiWindowFlags_NoCollapse;

if (no_nav) window_flags |= ImGuiWindowFlags_NoNav;

if (no_background) window_flags |= ImGuiWindowFlags_NoBackground;

if (no_bring_to_front) window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus;

if (no_close) p_open = NULL; // Don't pass our bool* to Begin

// We specify a default position/size in case there's no data in the .ini file.

// We only do it to make the demo applications a little more welcoming, but typically this isn't required.

ImGui::SetNextWindowPos(ImVec2(650, 20), ImGuiCond_FirstUseEver);

ImGui::SetNextWindowSize(ImVec2(550, 680), ImGuiCond_FirstUseEver);

// Main body of the Demo window starts here.

if (!ImGui::Begin("Dear ImGui Demo", p_open, window_flags))

{

// Early out if the window is collapsed, as an optimization.

ImGui::End();

return;

}

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

// e.g. Use 2/3 of the space for widgets and 1/3 for labels (default)

//ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.65f);

// e.g. Leave a fixed amount of width for labels (by passing a negative value), the rest goes to widgets.

ImGui::PushItemWidth(ImGui::GetFontSize() * -12);

// Menu Bar

if (ImGui::BeginMenuBar())

{

if (ImGui::BeginMenu("Menu"))

{

ShowExampleMenuFile();

ImGui::EndMenu();

}

if (ImGui::BeginMenu("Examples"))

{

ImGui::MenuItem("Main menu bar", NULL, &show_app_main_menu_bar);

ImGui::MenuItem("Console", NULL, &show_app_console);

ImGui::MenuItem("Log", NULL, &show_app_log);

ImGui::MenuItem("Simple layout", NULL, &show_app_layout);

ImGui::MenuItem("Property editor", NULL, &show_app_property_editor);

ImGui::MenuItem("Long text display", NULL, &show_app_long_text);

ImGui::MenuItem("Auto-resizing window", NULL, &show_app_auto_resize);

ImGui::MenuItem("Constrained-resizing window", NULL, &show_app_constrained_resize);

ImGui::MenuItem("Simple overlay", NULL, &show_app_simple_overlay);

ImGui::MenuItem("Manipulating window titles", NULL, &show_app_window_titles);

ImGui::MenuItem("Custom rendering", NULL, &show_app_custom_rendering);

ImGui::MenuItem("Documents", NULL, &show_app_documents);

ImGui::EndMenu();

}

if (ImGui::BeginMenu("Tools"))

{

ImGui::MenuItem("Metrics", NULL, &show_app_metrics);

ImGui::MenuItem("Style Editor", NULL, &show_app_style_editor);

ImGui::MenuItem("About Dear ImGui", NULL, &show_app_about);

ImGui::EndMenu();

}

ImGui::EndMenuBar();

}

ImGui::Text("dear imgui says hello. (%s)", IMGUI_VERSION);

ImGui::Spacing();

if (ImGui::CollapsingHeader("Help"))

{

ImGui::Text("ABOUT THIS DEMO:");

ImGui::BulletText("Sections below are demonstrating many aspects of the library.");

ImGui::BulletText("The \"Examples\" menu above leads to more demo contents.");

ImGui::BulletText("The \"Tools\" menu above gives access to: About Box, Style Editor,\n"

"and Metrics (general purpose Dear ImGui debugging tool).");

ImGui::Separator();

ImGui::Text("PROGRAMMER GUIDE:");

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("Read the FAQ at http://www.dearimgui.org/faq/");

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

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

ImGui::Separator();

ImGui::Text("USER GUIDE:");

ImGui::ShowUserGuide();

}

if (ImGui::CollapsingHeader("Configuration"))

{

ImGuiIO& io = ImGui::GetIO();

if (ImGui::TreeNode("Configuration##2"))

{

ImGui::CheckboxFlags("io.ConfigFlags: NavEnableKeyboard", &io.ConfigFlags, ImGuiConfigFlags_NavEnableKeyboard);

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

ImGui::SameLine(); HelpMarker("Required backend to feed in gamepad inputs in io.NavInputs[] and set io.BackendFlags |= ImGuiBackendFlags_HasGamepad.\n\nRead instructions in imgui.cpp for details.");

ImGui::CheckboxFlags("io.ConfigFlags: NavEnableSetMousePos", &io.ConfigFlags, ImGuiConfigFlags_NavEnableSetMousePos);

ImGui::SameLine(); HelpMarker("Instruct navigation to move the mouse cursor. See comment for ImGuiConfigFlags_NavEnableSetMousePos.");

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

if (io.ConfigFlags & ImGuiConfigFlags_NoMouse)

{

// The "NoMouse" option can get us stuck with a disabled mouse! Let's provide an alternative way to fix it:

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

{

ImGui::SameLine();

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

}

if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Space)))

io.ConfigFlags &= ~ImGuiConfigFlags_NoMouse;

}

ImGui::CheckboxFlags("io.ConfigFlags: NoMouseCursorChange", &io.ConfigFlags, ImGuiConfigFlags_NoMouseCursorChange);

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

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

ImGui::SameLine(); HelpMarker("Set to false to disable blinking cursor, for users who consider it distracting");

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

ImGui::SameLine(); HelpMarker("Enable resizing of windows from their edges and from the lower-left corner.\nThis requires (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors) because it needs mouse cursor feedback.");

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

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::Text("Also see Style->Rendering for rendering options.");

ImGui::TreePop();

ImGui::Separator();

}

if (ImGui::TreeNode("Backend Flags"))

{

HelpMarker(

"Those flags are set by the backends (imgui_impl_xxx files) to specify their capabilities.\n"

"Here we expose then as read-only fields to avoid breaking interactions with your backend.");

// Make a local copy to avoid modifying actual backend flags.

ImGuiBackendFlags backend_flags = io.BackendFlags;

ImGui::CheckboxFlags("io.BackendFlags: HasGamepad", &backend_flags, ImGuiBackendFlags_HasGamepad);

ImGui::CheckboxFlags("io.BackendFlags: HasMouseCursors", &backend_flags, ImGuiBackendFlags_HasMouseCursors);

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

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

ImGui::TreePop();

ImGui::Separator();

}

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

{

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

ImGui::ShowStyleEditor();

ImGui::TreePop();

ImGui::Separator();

}

if (ImGui::TreeNode("Capture/Logging"))

{

HelpMarker(

"The logging API redirects all text output so you can easily capture the content of "

"a window or a block. Tree nodes can be automatically expanded.\n"

"Try opening any of the contents below in this window and then click one of the \"Log To\" button.");

ImGui::LogButtons();

HelpMarker("You can also call ImGui::LogText() to output directly to the log without a visual output.");

if (ImGui::Button("Copy \"Hello, world!\" to clipboard"))

{

ImGui::LogToClipboard();

ImGui::LogText("Hello, world!");

ImGui::LogFinish();

}

ImGui::TreePop();

}

}

if (ImGui::CollapsingHeader("Window options"))

{

ImGui::Checkbox("No titlebar", &no_titlebar); ImGui::SameLine(150);

ImGui::Checkbox("No scrollbar", &no_scrollbar); ImGui::SameLine(300);

ImGui::Checkbox("No menu", &no_menu);

ImGui::Checkbox("No move", &no_move); ImGui::SameLine(150);

ImGui::Checkbox("No resize", &no_resize); ImGui::SameLine(300);

ImGui::Checkbox("No collapse", &no_collapse);

ImGui::Checkbox("No close", &no_close); ImGui::SameLine(150);

ImGui::Checkbox("No nav", &no_nav); ImGui::SameLine(300);

ImGui::Checkbox("No background", &no_background);

ImGui::Checkbox("No bring to front", &no_bring_to_front);

}

// All demo contents

ShowDemoWindowWidgets();

ShowDemoWindowLayout();

ShowDemoWindowPopups();

ShowDemoWindowColumns();

ShowDemoWindowMisc();

// End of ShowDemoWindow()

ImGui::End();

{

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

return;

if (ImGui::TreeNode("Basic"))

{

static int clicked = 0;

if (ImGui::Button("Button"))

clicked++;

if (clicked & 1)

{

ImGui::SameLine();

ImGui::Text("Thanks for clicking me!");

}

static bool check = true;

ImGui::Checkbox("checkbox", &check);

static int e = 0;

ImGui::RadioButton("radio a", &e, 0); ImGui::SameLine();

ImGui::RadioButton("radio b", &e, 1); ImGui::SameLine();

ImGui::RadioButton("radio c", &e, 2);

// Color buttons, demonstrate using PushID() to add unique identifier in the ID stack, and changing style.

for (int i = 0; i < 7; i++)

{

if (i > 0)

ImGui::SameLine();

ImGui::PushID(i);

ImGui::PushStyleColor(ImGuiCol_Button, (ImVec4)ImColor::HSV(i / 7.0f, 0.6f, 0.6f));

ImGui::PushStyleColor(ImGuiCol_ButtonHovered, (ImVec4)ImColor::HSV(i / 7.0f, 0.7f, 0.7f));

ImGui::PushStyleColor(ImGuiCol_ButtonActive, (ImVec4)ImColor::HSV(i / 7.0f, 0.8f, 0.8f));

ImGui::Button("Click");

ImGui::PopStyleColor(3);

ImGui::PopID();

}

// Use AlignTextToFramePadding() to align text baseline to the baseline of framed widgets elements

// (otherwise a Text+SameLine+Button sequence will have the text a little too high by default!)

// See 'Demo->Layout->Text Baseline Alignment' for details.

ImGui::AlignTextToFramePadding();

ImGui::Text("Hold to repeat:");

ImGui::SameLine();

// Arrow buttons with Repeater

static int counter = 0;

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

ImGui::PushButtonRepeat(true);

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

ImGui::SameLine(0.0f, spacing);

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

ImGui::PopButtonRepeat();

ImGui::SameLine();

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

ImGui::Text("Hover over me");

if (ImGui::IsItemHovered())

ImGui::SetTooltip("I am a tooltip");

ImGui::SameLine();

ImGui::Text("- or me");

if (ImGui::IsItemHovered())

{

ImGui::BeginTooltip();

ImGui::Text("I am a fancy tooltip");

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

ImGui::PlotLines("Curve", arr, IM_ARRAYSIZE(arr));

ImGui::EndTooltip();

}

ImGui::Separator();

ImGui::LabelText("label", "Value");

{

// Using the _simplified_ one-liner Combo() api here

// See "Combo" section for examples of how to use the more complete BeginCombo()/EndCombo() api.

const char* items[] = { "AAAA", "BBBB", "CCCC", "DDDD", "EEEE", "FFFF", "GGGG", "HHHH", "IIIIIII", "JJJJ", "KKKKKKK" };

static int item_current = 0;

ImGui::Combo("combo", &item_current, items, IM_ARRAYSIZE(items));

ImGui::SameLine(); HelpMarker(

"Refer to the \"Combo\" section below for an explanation of the full BeginCombo/EndCombo API, "

"and demonstration of various flags.\n");

}

{

// 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.

static char str0[128] = "Hello, world!";

ImGui::InputText("input text", str0, IM_ARRAYSIZE(str0));

ImGui::SameLine(); HelpMarker(

"USER:\n"

"Hold SHIFT or use mouse to select text.\n"

"CTRL+Left/Right to word jump.\n"

"CTRL+A or double-click to select all.\n"

"CTRL+X,CTRL+C,CTRL+V clipboard.\n"

"CTRL+Z,CTRL+Y undo/redo.\n"

"ESCAPE to revert.\n\n"

"PROGRAMMER:\n"

"You can use the ImGuiInputTextFlags_CallbackResize facility if you need to wire InputText() "

"to a dynamic string type. See misc/cpp/imgui_stdlib.h for an example (this is not demonstrated "

"in imgui_demo.cpp).");

static char str1[128] = "";

ImGui::InputTextWithHint("input text (w/ hint)", "enter text here", str1, IM_ARRAYSIZE(str1));

static int i0 = 123;

ImGui::InputInt("input int", &i0);

ImGui::SameLine(); HelpMarker(

"You can apply arithmetic operators +,*,/ on numerical values.\n"

" e.g. [ 100 ], input \'*2\', result becomes [ 200 ]\n"

"Use +- to subtract.");

static float f0 = 0.001f;

ImGui::InputFloat("input float", &f0, 0.01f, 1.0f, "%.3f");

static double d0 = 999999.00000001;

ImGui::InputDouble("input double", &d0, 0.01f, 1.0f, "%.8f");

static float f1 = 1.e10f;

ImGui::InputFloat("input scientific", &f1, 0.0f, 0.0f, "%e");

ImGui::SameLine(); HelpMarker(

"You can input value using the scientific notation,\n"

" e.g. \"1e+8\" becomes \"100000000\".");

static float vec4a[4] = { 0.10f, 0.20f, 0.30f, 0.44f };

ImGui::InputFloat3("input float3", vec4a);

}

{

static int i1 = 50, i2 = 42;

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

}

{

static int i1 = 0;

ImGui::SliderInt("slider int", &i1, -1, 3);

ImGui::SameLine(); HelpMarker("CTRL+click to input value.");

static float f1 = 0.123f, f2 = 0.0f;

ImGui::SliderFloat("slider float", &f1, 0.0f, 1.0f, "ratio = %.3f");

ImGui::SliderFloat("slider float (log)", &f2, -10.0f, 10.0f, "%.4f", ImGuiSliderFlags_Logarithmic);

static float angle = 0.0f;

ImGui::SliderAngle("slider angle", &angle);

// Using the format string to display a name instead of an integer.

// Here we completely omit '%d' from the format string, so it'll only display a name.

// This technique can also be used with DragInt().

enum Element { Element_Fire, Element_Earth, Element_Air, Element_Water, Element_COUNT };

static int elem = Element_Fire;

const char* elems_names[Element_COUNT] = { "Fire", "Earth", "Air", "Water" };

const char* elem_name = (elem >= 0 && elem < Element_COUNT) ? elems_names[elem] : "Unknown";

ImGui::SliderInt("slider enum", &elem, 0, Element_COUNT - 1, elem_name);

ImGui::SameLine(); HelpMarker("Using the format string parameter to display a name instead of the underlying integer.");

}

{

static float col1[3] = { 1.0f, 0.0f, 0.2f };

static float col2[4] = { 0.4f, 0.7f, 0.0f, 0.5f };

ImGui::ColorEdit3("color 1", col1);

ImGui::SameLine(); HelpMarker(

"Click on the color square to open a color picker.\n"

"Click and hold to use drag and drop.\n"

"Right-click on the color square to show options.\n"

"CTRL+click on individual component to input value.\n");

ImGui::ColorEdit4("color 2", col2);

}

{

// List box

const char* items[] = { "Apple", "Banana", "Cherry", "Kiwi", "Mango", "Orange", "Pineapple", "Strawberry", "Watermelon" };

static int item_current = 1;

ImGui::ListBox("listbox\n(single select)", &item_current, items, IM_ARRAYSIZE(items), 4);

//static int listbox_item_current2 = 2;

//ImGui::SetNextItemWidth(-1);

//ImGui::ListBox("##listbox2", &listbox_item_current2, listbox_items, IM_ARRAYSIZE(listbox_items), 4);

}

ImGui::TreePop();

}

// Testing ImGuiOnceUponAFrame helper.

//static ImGuiOnceUponAFrame once;

//for (int i = 0; i < 5; i++)

// if (once)

// ImGui::Text("This will be displayed only once.");

if (ImGui::TreeNode("Trees"))

{

if (ImGui::TreeNode("Basic trees"))

{

for (int i = 0; i < 5; i++)

{

// Use SetNextItemOpen() so set the default state of a node to be open. We could

// also use TreeNodeEx() with the ImGuiTreeNodeFlags_DefaultOpen flag to achieve the same thing!

if (i == 0)

ImGui::SetNextItemOpen(true, ImGuiCond_Once);

if (ImGui::TreeNode((void*)(intptr_t)i, "Child %d", i))

{

ImGui::Text("blah blah");

ImGui::SameLine();

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

ImGui::TreePop();

}

}

ImGui::TreePop();

}

if (ImGui::TreeNode("Advanced, with Selectable nodes"))

{

HelpMarker(

"This is a more typical looking tree with selectable nodes.\n"

"Click to select, CTRL+Click to toggle, click on arrows or double-click to open.");

static ImGuiTreeNodeFlags base_flags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_SpanAvailWidth;

static bool align_label_with_current_x_position = false;

static bool test_drag_and_drop = false;

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

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::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!");

if (align_label_with_current_x_position)

ImGui::Unindent(ImGui::GetTreeNodeToLabelSpacing());

// 'selection_mask' is dumb representation of what may be user-side selection state.

// You may retain selection state inside or outside your objects in whatever format you see fit.

// 'node_clicked' is temporary storage of what node we have clicked to process selection at the end

/// of the loop. May be a pointer to your own node type, etc.

static int selection_mask = (1 << 2);

int node_clicked = -1;

for (int i = 0; i < 6; i++)

{

// Disable the default "open on single-click behavior" + set Selected flag according to our selection.

ImGuiTreeNodeFlags node_flags = base_flags;

const bool is_selected = (selection_mask & (1 << i)) != 0;

if (is_selected)

node_flags |= ImGuiTreeNodeFlags_Selected;

if (i < 3)

{

// Items 0..2 are Tree Node

bool node_open = ImGui::TreeNodeEx((void*)(intptr_t)i, node_flags, "Selectable Node %d", i);

if (ImGui::IsItemClicked())

node_clicked = i;

if (test_drag_and_drop && ImGui::BeginDragDropSource())

{

ImGui::SetDragDropPayload("_TREENODE", NULL, 0);

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

ImGui::EndDragDropSource();

}

if (node_open)

{

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

ImGui::TreePop();

}

}

else

{

// Items 3..5 are Tree Leaves

// The only reason we use TreeNode at all is to allow selection of the leaf. Otherwise we can

// use BulletText() or advance the cursor by GetTreeNodeToLabelSpacing() and call Text().

node_flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen; // ImGuiTreeNodeFlags_Bullet

ImGui::TreeNodeEx((void*)(intptr_t)i, node_flags, "Selectable Leaf %d", i);

if (ImGui::IsItemClicked())

node_clicked = i;

if (test_drag_and_drop && ImGui::BeginDragDropSource())

{

ImGui::SetDragDropPayload("_TREENODE", NULL, 0);

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

ImGui::EndDragDropSource();

}

}

}

if (node_clicked != -1)

{

// Update selection state

// (process outside of tree loop to avoid visual inconsistencies during the clicking frame)

if (ImGui::GetIO().KeyCtrl)

selection_mask ^= (1 << node_clicked); // CTRL+click to toggle

else //if (!(selection_mask & (1 << node_clicked))) // Depending on selection behavior you want, may want to preserve selection when clicking on item that is part of the selection

selection_mask = (1 << node_clicked); // Click to single-select

}

if (align_label_with_current_x_position)

ImGui::Indent(ImGui::GetTreeNodeToLabelSpacing());

ImGui::TreePop();

}

ImGui::TreePop();

}

if (ImGui::TreeNode("Collapsing Headers"))

{

static bool closable_group = true;

ImGui::Checkbox("Show 2nd header", &closable_group);

if (ImGui::CollapsingHeader("Header", ImGuiTreeNodeFlags_None))

{

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

for (int i = 0; i < 5; i++)

ImGui::Text("Some content %d", i);

}

if (ImGui::CollapsingHeader("Header with a close button", &closable_group))

{

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

for (int i = 0; i < 5; i++)

ImGui::Text("More content %d", i);

}

/*

ImGui::TreePop();

}

if (ImGui::TreeNode("Bullets"))

{

ImGui::BulletText("Bullet point 1");

ImGui::BulletText("Bullet point 2\nOn multiple lines");

if (ImGui::TreeNode("Tree node"))

{

ImGui::BulletText("Another bullet point");

ImGui::TreePop();

}

ImGui::Bullet(); ImGui::Text("Bullet point 3 (two calls)");

ImGui::Bullet(); ImGui::SmallButton("Button");

ImGui::TreePop();

}

if (ImGui::TreeNode("Text"))

{

if (ImGui::TreeNode("Colorful Text"))

{

// Using shortcut. You can use PushStyleColor()/PopStyleColor() for more flexibility.

ImGui::TextColored(ImVec4(1.0f, 0.0f, 1.0f, 1.0f), "Pink");

ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.0f, 1.0f), "Yellow");

ImGui::TextDisabled("Disabled");

ImGui::SameLine(); HelpMarker("The TextDisabled color is stored in ImGuiStyle.");

ImGui::TreePop();

}

if (ImGui::TreeNode("Word Wrapping"))

{

// Using shortcut. You can use PushTextWrapPos()/PopTextWrapPos() for more flexibility.

ImGui::TextWrapped(

"This text should automatically wrap on the edge of the window. The current implementation "

"for text wrapping follows simple rules suitable for English and possibly other languages.");

ImGui::Spacing();

static float wrap_width = 200.0f;

ImGui::SliderFloat("Wrap width", &wrap_width, -20, 600, "%.0f");

ImDrawList* draw_list = ImGui::GetWindowDrawList();

for (int n = 0; n < 2; n++)

{

ImGui::Text("Test paragraph %d:", n);

ImVec2 pos = ImGui::GetCursorScreenPos();

ImVec2 marker_min = ImVec2(pos.x + wrap_width, pos.y);

ImVec2 marker_max = ImVec2(pos.x + wrap_width + 10, pos.y + ImGui::GetTextLineHeight());

ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + wrap_width);

if (n == 0)

ImGui::Text("The lazy dog is a good dog. This paragraph should fit within %.0f pixels. Testing a 1 character word. The quick brown fox jumps over the lazy dog.", wrap_width);

else

ImGui::Text("aaaaaaaa bbbbbbbb, c cccccccc,dddddddd. d eeeeeeee ffffffff. gggggggg!hhhhhhhh");

// Draw actual text bounding box, following by marker of our expected limit (should not overlap!)

draw_list->AddRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax(), IM_COL32(255, 255, 0, 255));

draw_list->AddRectFilled(marker_min, marker_max, IM_COL32(255, 0, 255, 255));

ImGui::PopTextWrapPos();

}

ImGui::TreePop();

}

if (ImGui::TreeNode("UTF-8 Text"))

{

// UTF-8 test with Japanese characters

// (Needs a suitable font? Try "Google Noto" or "Arial Unicode". See docs/FONTS.md for details.)

// - From C++11 you can use the u8"my text" syntax to encode literal strings as UTF-8

// - For earlier compiler, you may be able to encode your sources as UTF-8 (e.g. in Visual Studio, you

// can save your source files as 'UTF-8 without signature').

// - FOR THIS DEMO FILE ONLY, BECAUSE WE WANT TO SUPPORT OLD COMPILERS, WE ARE *NOT* INCLUDING RAW UTF-8

// CHARACTERS IN THIS SOURCE FILE. Instead we are encoding a few strings with hexadecimal constants.

// Don't do this in your application! Please use u8"text in any language" in your application!

// Note that characters values are preserved even by InputText() if the font cannot be displayed,

// so you can safely copy & paste garbled characters into another application.

ImGui::TextWrapped(

"CJK text will only appears if the font was loaded with the appropriate CJK character ranges. "

"Call io.Font->AddFontFromFileTTF() manually to load extra character ranges. "

"Read docs/FONTS.md for details.");

ImGui::Text("Hiragana: \xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93 (kakikukeko)"); // Normally we would use u8"blah blah" with the proper characters directly in the string.

ImGui::Text("Kanjis: \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e (nihongo)");

static char buf[32] = "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e";

//static char buf[32] = u8"NIHONGO"; // <- this is how you would write it with C++11, using real kanjis

ImGui::InputText("UTF-8 input", buf, IM_ARRAYSIZE(buf));

ImGui::TreePop();

}

ImGui::TreePop();

}

if (ImGui::TreeNode("Images"))

{

ImGuiIO& io = ImGui::GetIO();

ImGui::TextWrapped(

"Below we are displaying the font texture (which is the only texture we have access to in this demo). "

"Use the 'ImTextureID' type as storage to pass pointers or identifier to your own texture data. "

"Hover the texture for a zoomed view!");

// Below we are displaying the font texture because it is the only texture we have access to inside the demo!

// Remember that ImTextureID is just storage for whatever you want it to be. It is essentially a value that

// will be passed to the rendering backend via the ImDrawCmd structure.

// If you use one of the default imgui_impl_XXXX.cpp rendering backend, they all have comments at the top

// of their respective source file to specify what they expect to be stored in ImTextureID, for example:

// - The imgui_impl_dx11.cpp renderer expect a 'ID3D11ShaderResourceView*' pointer

// - The imgui_impl_opengl3.cpp renderer expect a GLuint OpenGL texture identifier, etc.

// More:

// - If you decided that ImTextureID = MyEngineTexture*, then you can pass your MyEngineTexture* pointers

// to ImGui::Image(), and gather width/height through your own functions, etc.

// - You can use ShowMetricsWindow() to inspect the draw data that are being passed to your renderer,

// it will help you debug issues if you are confused about it.

// - Consider using the lower-level ImDrawList::AddImage() API, via ImGui::GetWindowDrawList()->AddImage().

// - Read https://github.com/ocornut/imgui/blob/master/docs/FAQ.md

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

ImTextureID my_tex_id = io.Fonts->TexID;

float my_tex_w = (float)io.Fonts->TexWidth;

float my_tex_h = (float)io.Fonts->TexHeight;

{

ImGui::Text("%.0fx%.0f", my_tex_w, my_tex_h);

ImVec2 pos = ImGui::GetCursorScreenPos();

ImVec2 uv_min = ImVec2(0.0f, 0.0f); // Top-left

ImVec2 uv_max = ImVec2(1.0f, 1.0f); // Lower-right

ImVec4 tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f); // No tint

ImVec4 border_col = ImVec4(1.0f, 1.0f, 1.0f, 0.5f); // 50% opaque white

ImGui::Image(my_tex_id, ImVec2(my_tex_w, my_tex_h), uv_min, uv_max, tint_col, border_col);

if (ImGui::IsItemHovered())

{

ImGui::BeginTooltip();

float region_sz = 32.0f;

float region_x = io.MousePos.x - pos.x - region_sz * 0.5f;

float region_y = io.MousePos.y - pos.y - region_sz * 0.5f;

float zoom = 4.0f;

if (region_x < 0.0f) { region_x = 0.0f; }

else if (region_x > my_tex_w - region_sz) { region_x = my_tex_w - region_sz; }

if (region_y < 0.0f) { region_y = 0.0f; }

else if (region_y > my_tex_h - region_sz) { region_y = my_tex_h - region_sz; }

ImGui::Text("Min: (%.2f, %.2f)", region_x, region_y);

ImGui::Text("Max: (%.2f, %.2f)", region_x + region_sz, region_y + region_sz);

ImVec2 uv0 = ImVec2((region_x) / my_tex_w, (region_y) / my_tex_h);

ImVec2 uv1 = ImVec2((region_x + region_sz) / my_tex_w, (region_y + region_sz) / my_tex_h);

ImGui::Image(my_tex_id, ImVec2(region_sz * zoom, region_sz * zoom), uv0, uv1, tint_col, border_col);

ImGui::EndTooltip();

}

}

ImGui::TextWrapped("And now some textured buttons..");

static int pressed_count = 0;

for (int i = 0; i < 8; i++)

{

ImGui::PushID(i);

int frame_padding = -1 + i; // -1 == uses default padding (style.FramePadding)

ImVec2 size = ImVec2(32.0f, 32.0f); // Size of the image we want to make visible

ImVec2 uv0 = ImVec2(0.0f, 0.0f); // UV coordinates for lower-left

ImVec2 uv1 = ImVec2(32.0f / my_tex_w, 32.0f / my_tex_h);// UV coordinates for (32,32) in our texture

ImVec4 bg_col = ImVec4(0.0f, 0.0f, 0.0f, 1.0f); // Black background

ImVec4 tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f); // No tint

if (ImGui::ImageButton(my_tex_id, size, uv0, uv1, frame_padding, bg_col, tint_col))

pressed_count += 1;

ImGui::PopID();

ImGui::SameLine();

}

ImGui::NewLine();

ImGui::Text("Pressed %d times.", pressed_count);

ImGui::TreePop();

}

if (ImGui::TreeNode("Combo"))

{

// Expose flags as checkbox for the demo

static ImGuiComboFlags flags = 0;

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

ImGui::SameLine(); HelpMarker("Only makes a difference if the popup is larger than the combo");

if (ImGui::CheckboxFlags("ImGuiComboFlags_NoArrowButton", &flags, ImGuiComboFlags_NoArrowButton))

flags &= ~ImGuiComboFlags_NoPreview; // Clear the other flag, as we cannot combine both

if (ImGui::CheckboxFlags("ImGuiComboFlags_NoPreview", &flags, ImGuiComboFlags_NoPreview))

flags &= ~ImGuiComboFlags_NoArrowButton; // Clear the other flag, as we cannot combine both

// Using the generic BeginCombo() API, you have full control over how to display the combo contents.

// (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" };

static int item_current_idx = 0; // Here our selection data is an index.

const char* combo_label = items[item_current_idx]; // Label to preview before opening the combo (technically it could be anything)

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

{

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

{

const bool is_selected = (item_current_idx == n);

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

item_current_idx = n;

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

if (is_selected)

ImGui::SetItemDefaultFocus();

}

ImGui::EndCombo();

}

// Simplified one-liner Combo() API, using values packed in a single constant string