Blender's GPU Accelerated UI, Decoupled from it's original codebase. Supports Rust, Python, JS, React, C & C++. Twice as good as GPUI
feat: dearimgui widgets
Preetham Pemmasanicef9e4173c43
diff --git a/bindings/imgui/CMakeLists.txt b/bindings/imgui/CMakeLists.txtindex 73c73e7..0571dd3 100644--- a/bindings/imgui/CMakeLists.txt+++ b/bindings/imgui/CMakeLists.txt@@ -5,11 +5,20 @@# SPDX-License-Identifier: GPL-2.0-or-laterset(IMGUI_DIR ${CMAKE_CURRENT_SOURCE_DIR}/extern/imgui)+# Blender widgets: ImGui's widgets drawn and handled as Blender's (blender/README.md). The+# copy blender/imgui_widgets_blender.cpp replaces imgui_widgets.cpp: same API and ABI, so+# the C / Python / Rust bindings get Blender widgets unchanged.+option(BUI_IMGUI_BLENDER_WIDGETS "Dear ImGui on BUI: Blender's widgets (blender/imgui_widgets_blender.cpp)" OFF)+if(BUI_IMGUI_BLENDER_WIDGETS)+ set(BUI_IMGUI_WIDGETS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/blender/imgui_widgets_blender.cpp)+else()+ set(BUI_IMGUI_WIDGETS_SRC ${IMGUI_DIR}/imgui_widgets.cpp)+endif()set(BUI_IMGUI_CORE${IMGUI_DIR}/imgui.cpp${IMGUI_DIR}/imgui_draw.cpp${IMGUI_DIR}/imgui_tables.cpp- ${IMGUI_DIR}/imgui_widgets.cpp+ ${BUI_IMGUI_WIDGETS_SRC}${IMGUI_DIR}/imgui_demo.cpp${IMGUI_DIR}/misc/cpp/imgui_stdlib.cpp)@@ -28,6 +37,9 @@ target_include_directories(bui_imgui PUBLIC${IMGUI_DIR}/misc/cpp)target_link_libraries(bui_imgui PUBLIC bui::kit)+if(BUI_IMGUI_BLENDER_WIDGETS)+ target_compile_definitions(bui_imgui PUBLIC BUI_IMGUI_BLENDER_WIDGETS=1)+endif()# The C API (cimgui-style, generated by gen/gen.py) and the C API of the BUI backend.add_library(bui_cimgui STATIC c/cimgui.cpp c/cimgui_impl_bui.cpp)@@ -48,6 +60,17 @@ if(EXISTS ${CMAKE_SOURCE_DIR}/examples/imgui_demo.cpp)target_include_directories(bui_imgui_demo PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/tests)target_link_libraries(bui_imgui_demo PRIVATE bui::imgui)endif()+# examples/imgui_blender_compare.cpp: ImGui's widgets next to the kit's native ones (PNGs)+if(EXISTS ${CMAKE_SOURCE_DIR}/examples/imgui_blender_compare.cpp)+ add_executable(bui_imgui_compare ${CMAKE_SOURCE_DIR}/examples/imgui_blender_compare.cpp)+ target_include_directories(bui_imgui_compare PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/tests)+ target_link_libraries(bui_imgui_compare PRIVATE bui::imgui)+ if(BUI_BUILD_TESTS AND BUI_IMGUI_BLENDER_WIDGETS)+ # ImGui's Blender widgets and the kit's native widgets: the same pixels+ add_test(NAME imgui_blender_widgets_match_kit COMMAND bui_imgui_compare ${CMAKE_CURRENT_BINARY_DIR})+ set_tests_properties(imgui_blender_widgets_match_kit PROPERTIES TIMEOUT 300)+ endif()+endif()if(EXISTS ${CMAKE_SOURCE_DIR}/examples/imgui_demo_c.c)add_executable(bui_imgui_demo_c ${CMAKE_SOURCE_DIR}/examples/imgui_demo_c.c)target_link_libraries(bui_imgui_demo_c PRIVATE bui::cimgui)@@ -58,6 +81,9 @@ if(BUI_BUILD_TESTS)# section of the demo), so it does not link bui_imgui.add_executable(bui_imgui_test tests/test_imgui_bui.cpp ${BUI_IMGUI_CORE} ${BUI_IMGUI_BACKEND})target_compile_definitions(bui_imgui_test PRIVATE IMGUI_ENABLE_TEST_ENGINE)+ if(BUI_IMGUI_BLENDER_WIDGETS)+ target_compile_definitions(bui_imgui_test PRIVATE BUI_IMGUI_BLENDER_WIDGETS=1)+ endif()target_include_directories(bui_imgui_test PRIVATE${CMAKE_CURRENT_SOURCE_DIR} ${IMGUI_DIR} ${IMGUI_DIR}/misc/cpp ${CMAKE_CURRENT_SOURCE_DIR}/tests)target_link_libraries(bui_imgui_test PRIVATE bui::kit)diff --git a/bindings/imgui/README.md b/bindings/imgui/README.mdindex 3fa5650..a84006d 100644--- a/bindings/imgui/README.md+++ b/bindings/imgui/README.md@@ -17,6 +17,12 @@ Blender's UI font (Inter, embedded in BUI).(`py -3 -I bindings/imgui/gen/gen.py`): the C API `c/cimgui.h` (CMake `bui_cimgui`, with`c/cimgui_impl_bui.h` for this backend), `blenderui.imgui` for Python (`_buiimgui`) and the`blenderui-imgui` crate. See [docs/imgui.md](../../docs/imgui.md).+- **Blender widgets:** `-DBUI_IMGUI_BLENDER_WIDGETS=ON` (default OFF) compiles+ `blender/imgui_widgets_blender.cpp` instead of `imgui_widgets.cpp`: ImGui's widgets are+ then drawn by the kit as Blender's own widgets (same pixels as the kit's native ones) and+ number fields, sliders and checkboxes follow Blender's interaction; same API and ABI, so+ every binding gets them (cargo feature `blender-widgets`). Mapping, behavior differences+ and gaps: [blender/README.md](blender/README.md).## Using it@@ -109,8 +115,8 @@ unit (U = 20 px at scale 1) and `uiStyle`:"Hover" is Blender's `widget_active_color`: HSL saturation x1.15, lightness x1.2.-Metrics (scaled by `BK_scale()`): frame height one widget unit (FramePadding.y = (20 --font) / 2), FrameRounding / ChildRounding / PopupRounding / TabRounding = roundness 0.2 x U+Metrics (scaled by `BK_scale()`): frame height one widget unit (FramePadding.y = (U -+font) / 2 after ImGui's rounding of the font to whole pixels: 3.5 at scale 1), FrameRounding / ChildRounding / PopupRounding / TabRounding = roundness 0.2 x U= 4 px, WindowRounding = `panel_roundness` 0.4 x U / 2 = 4 px, scrollbars `V2D_SCROLL_WIDTH`(0.45 U + 2 = 11 px) with round ends, ItemSpacing = `buttonspacex/y` (8, 2),ItemInnerSpacing.x = `templatespace` (5), IndentSpacing = U, 1 px window/frame/popupdiff --git a/bindings/imgui/blender/README.md b/bindings/imgui/blender/README.mdnew file mode 100644index 0000000..e93be44--- /dev/null+++ b/bindings/imgui/blender/README.md@@ -0,0 +1,124 @@+# Blender widgets for Dear ImGui (`BUI_IMGUI_BLENDER_WIDGETS`)++A build of Dear ImGui on BUI in which ImGui's widgets **are** Blender's widgets: drawn by+the BUI kit with the same code as its native widgets (the `interface_widgets.cc` port in+`kit/intern/kit_draw.c`, Blender's theme, Inter text), and handled with Blender's+interaction rules (`interface_handlers.cc`) where Blender behaves differently. The whole+Dear ImGui API keeps working, so the C, Python and Rust bindings get Blender widgets with+no change.++```sh+cmake -S . -B build -DBUI_IMGUI_BLENDER_WIDGETS=ON # default OFF+cargo build -p blenderui-imgui --features blender-widgets+```++At runtime `ImGui_ImplBUI_SetBlenderWidgets(false)` (C `cImGui_ImplBUI_SetBlenderWidgets`,+Python `imgui.set_blender_widgets`, Rust `set_blender_widgets`) goes back to ImGui's own+drawing and interaction; `ImGui_ImplBUI_HasBlenderWidgets()` tells whether the build has them.++## How it works++- `imgui_widgets_blender.cpp` is a copy of `extern/imgui/imgui_widgets.cpp` (1.93.1 WIP)+ that CMake compiles **instead of** it: same functions, same ABI. Every edit is marked+ `BUI:`. ImGui's item / ID / layout / navigation logic and its text-editing engine are+ untouched; the rendering of each widget becomes a draw-list callback and, for number+ fields, sliders and checkboxes, the mouse interaction follows Blender.+- A widget is emitted as `ImDrawList::AddCallback(ImGui_ImplBUI_DrawCallback_Widget, data)`+ where `data` is a `BKWidgetDraw` (kind, rect, state: hover / pressed / selected /+ disabled / editing / arrow-zone hover / mixed / open, value or fill factor, corners for+ aligned groups, color, text rect) followed by its texts. The BUI backend+ (`imgui_impl_bui.cpp`) runs callbacks in draw order while rendering and calls the kit's+ `BK_draw_widget(raster, &w)` (`kit/intern/kit_draw.c`), clipped to the command's clip rect.+- Text in widgets (labels, values, `ImGui::Text`, tree / menu / tab labels, an idle text+ field) is drawn by BUI's text, as the kit's widgets draw theirs, when ImGui uses Blender's+ font (Inter) at Blender's size; other fonts or sizes keep ImGui's own glyphs.+- The draw data hash includes the callback data, so the backend's "redraw only on change"+ still works; the GPU renderers draw the same as the software raster (text antialiasing+ aside, as for every kit widget).++`ctest -R imgui_blender_widgets_match_kit` (`examples/imgui_blender_compare.cpp`) renders+the kit's native checkbox, number field, number slider, aligned vector, text field, button,+menu button, progress bar and color swatch next to the same widgets through ImGui and+requires the two columns to be **the same pixels** (0 differ at scale 1).++## Mapping++| ImGui | Blender widget (kit drawing) | Interaction |+|---|---|---|+| `Button`, `SmallButton` | push button (`wcol_regular`, `button_draw`), label centered | ImGui's (press on release) |+| `ArrowButton` | push button with a triangle | ImGui's |+| `InvisibleButton` | nothing drawn | ImGui's |+| `Checkbox`, `CheckboxFlags` | option box + label (`wcol_option`, `checkbox_draw`), dash when mixed | Blender: toggles on **press**; **drag-toggle**: drag over other checkboxes to give them the same state |+| `RadioButton` | option widget, round, with a dot (Blender has no round radio; its "radio" is a segmented row) | ImGui's |+| `Selectable` | list row (`wcol_list_item`); in popups / menus a menu row (`wcol_menu_item`); in menu bars a pulldown (`wcol_pulldown`) | ImGui's |+| `DragFloat/Int/Scalar(N)`, `DragFloatRange2`, `DragIntRange2` | number field (`wcol_num`, `number_draw`): step arrows on hover, value centered | Blender (`ui_do_but_NUM`): drag past 0.25 U scrubs `v_speed` per pixel, **Shift** 1/10 the speed, **Ctrl** snaps (Ctrl+Shift finer), click on an arrow steps by `v_speed` (ints: 1), click elsewhere / Ctrl+click types, Escape reverts; horizontal-arrows cursor |+| `SliderFloat/Int/Scalar(N)`, `SliderAngle` | number slider (`wcol_numslider`, `slider_draw`): fill bar, value inside | Blender (`ui_do_but_SLI`): drag is **relative** to the press (no jump to the pointer), **Shift** 1/20 the speed, **Ctrl** snaps, click / Ctrl+click types |+| `VSliderFloat/Int/Scalar` | ImGui's vertical slider (Blender has none), Blender colors | ImGui's |+| `InputText`, `InputTextWithHint`, `InputFloat/Int/Double/Scalar(N)` | text field (`wcol_text`, `text_draw`; while typing the `text_sel` look), text 0.4 U from the edge; +/- are Blender buttons | ImGui's text engine |+| `InputTextMultiline` | text field backdrop | ImGui's |+| `Combo`, `BeginCombo` | menu button (`wcol_menu`, the pulldown arrows, preview left) ; popup: Blender menu backdrop with its shadow (`wcol_menu_back`) + menu rows | ImGui's |+| `ColorButton`, `ColorEdit3/4` | color swatch (`swatch_draw`: opaque left half, checker under the alpha half); components as an aligned row of number fields | Blender number fields |+| `ColorPicker3/4` | ImGui's picker (Blender colors) — see gaps | ImGui's |+| `ProgressBar` | progress bar (`wcol_progress`), text centered | — |+| `CollapsingHeader`, framed `TreeNode` | panel header (`panel_draw`: arrow icon, title with the soft shadow) | ImGui's |+| `TreeNode` | tree row (`tree_draw_row`): disclosure triangle icon, list-row hover / selection | ImGui's |+| `BeginTabBar`, `BeginTabItem` | tabs (`wcol_tab`, `tabs_draw`): the current one `inner_sel` with `text_sel`, others `text` | ImGui's |+| `BeginMenuBar`, `BeginMenu` | pulldowns in the bar; menu: Blender menu backdrop with shadow, menu rows, submenu arrow | ImGui's |+| `MenuItem` | menu row (hover highlight, shortcut at 55% text alpha), `selected` shows Blender's menu check box | ImGui's |+| `Separator`, `SeparatorText` | ImGui's line in the Blender separator color (text at 15%) | — |+| `Text`, `LabelText`, `BulletText`, `TextWrapped`, ... | BUI's text (Inter), ImGui's wrapping | — |+| windows, title bars, tooltips, popups from `BeginPopup`, tables, scrollbars, plots | ImGui's, in the Blender style (`ImGui_ImplBUI_StyleBlender`) | ImGui's |++"Label: value" formats: a number field or slider whose format has a `:` (e.g. `"Width: %.0f"`,+ColorEdit's `"R:%3d"`) shows Blender's way: the label on the left, the value on the right.+Other formats are centered. The `label` argument stays outside on the right, where ImGui+lays it out (decided so that layouts, `CalcItemWidth` and label columns keep working).++Aligned groups: the components of `DragFloat2/3/4`, `DragInt*`, `SliderFloat2/3/4`,+`SliderInt*`, `Drag*Range2` and `ColorEdit` are joined into one rounded row as Blender+aligns vectors (no gap, inner corners square), instead of ImGui's `ItemInnerSpacing` gaps.++## Differences from ImGui's widgets (behavior)++- Sliders: a press does not move the value; dragging changes it relative to where the+ press was; a click without a drag types a value. ImGui jumps to the pointer on press.+- Number fields (`Drag*`): a click without a drag types a value (ImGui needs Ctrl+click,+ double-click, or `io.ConfigDragClickToInputText`); the arrow zones step; the drag begins+ after 0.25 widget units (ImGui: half `io.MouseDragThreshold`); **Shift** is 10x *slower*+ (Blender precision; ImGui: Shift faster, Alt slower) and **Ctrl** snaps while dragging.+ A quick second press is a new drag, not a double-click.+- Checkboxes toggle on press and support drag-toggle (ImGui toggles on release).+- Logarithmic sliders / drags, reversed slider ranges, keyboard and gamepad keep ImGui's+ interaction (drawn as Blender widgets).+- Text fields place their text 0.4 widget units from the left edge (Blender's+ `UI_TEXT_MARGIN_X`), not `FramePadding.x`.+- `MenuItem` check marks are Blender's check box in ImGui's mark column (Blender puts the+ box on the left).++## Gaps++- Blender's vertical multi-value drag (drag down over fields, then sideways) and Alt+ (edit all linked fields) are not implemented; the cursor is not hidden / warped while+ scrubbing.+- Code in `imgui.cpp` / `imgui_tables.cpp` is not copied: window title bars and frames,+ tooltips, `BeginPopup` / context-menu backgrounds (only combos and `BeginMenu` menus get+ Blender's menu backdrop), table headers and window titles keep ImGui's rendering in the+ Blender style and ImGui's glyphs.+- `ColorPicker3/4` (Blender's HSV circle is not ported to the kit), `VSlider*`, `PlotLines` /+ `PlotHistogram`, `ImageButton`, `Bullet` and `TextLink` keep ImGui's drawing.+- Text being typed uses ImGui's glyphs (its cursor and selection are measured with them).+- Indeterminate `ProgressBar` (negative fraction) shows the moving end of ImGui's segment.++## Keeping the copy current++`rebase.py` (stdlib Python + git):++```sh+# after copying a newer Dear ImGui into extern/imgui, before committing it:+py -3 bindings/imgui/blender/rebase.py merge # 3-way merge old upstream -> new, onto the copy+py -3 bindings/imgui/blender/rebase.py check # every changed hunk carries a BUI: mark+py -3 bindings/imgui/blender/rebase.py diff # the BUI edits as a unified diff+```++Then build with `-DBUI_IMGUI_BLENDER_WIDGETS=ON` and run `ctest` (`imgui_backend`,+`imgui_c_api`, `imgui_blender_widgets_match_kit`, `buipy_imgui`).diff --git a/bindings/imgui/blender/imgui_widgets_blender.cpp b/bindings/imgui/blender/imgui_widgets_blender.cppnew file mode 100644index 0000000..63099ea--- /dev/null+++ b/bindings/imgui/blender/imgui_widgets_blender.cpp@@ -0,0 +1,12096 @@+// dear imgui, v1.93.1 WIP+// (widgets code)++/*++Index of this file:++// [SECTION] Forward Declarations+// [SECTION] Widgets: Text, etc.+// [SECTION] Widgets: Main (Button, Image, Checkbox, RadioButton, ProgressBar, Bullet, etc.)+// [SECTION] Widgets: Low-level Layout helpers (Spacing, Dummy, NewLine, Separator, etc.)+// [SECTION] Widgets: ComboBox+// [SECTION] Data Type and Data Formatting Helpers+// [SECTION] Widgets: DragScalar, DragFloat, DragInt, etc.+// [SECTION] Widgets: SliderScalar, SliderFloat, SliderInt, etc.+// [SECTION] Widgets: InputScalar, InputFloat, InputInt, etc.+// [SECTION] Widgets: InputText, InputTextMultiline+// [SECTION] Widgets: ColorEdit, ColorPicker, ColorButton, etc.+// [SECTION] Widgets: TreeNode, CollapsingHeader, etc.+// [SECTION] Widgets: Selectable+// [SECTION] Widgets: Typing-Select support+// [SECTION] Widgets: Box-Select support+// [SECTION] Widgets: Multi-Select support+// [SECTION] Widgets: Multi-Select helpers+// [SECTION] Widgets: ListBox+// [SECTION] Widgets: PlotLines, PlotHistogram+// [SECTION] Widgets: Value helpers+// [SECTION] Widgets: MenuItem, BeginMenu, EndMenu, etc.+// [SECTION] Widgets: BeginTabBar, EndTabBar, etc.+// [SECTION] Widgets: BeginTabItem, EndTabItem, etc.+// [SECTION] Widgets: Columns, BeginColumns, EndColumns, etc.++*/++#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)+#define _CRT_SECURE_NO_WARNINGS+#endif++#ifndef IMGUI_DEFINE_MATH_OPERATORS+#define IMGUI_DEFINE_MATH_OPERATORS+#endif++#include "imgui.h"+#ifndef IMGUI_DISABLE+#include "imgui_internal.h"++// System includes+#include <stdint.h> // intptr_t++//-------------------------------------------------------------------------+// Warnings+//-------------------------------------------------------------------------++// Visual Studio warnings+#ifdef _MSC_VER+#pragma warning (disable: 4127) // condition expression is constant+#pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen+#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later+#pragma warning (disable: 5054) // operator '|': deprecated between enumerations of different types+#endif+#pragma warning (disable: 26451) // [Static Analyzer] Arithmetic overflow : Using operator 'xxx' on a 4 byte value and then casting the result to a 8 byte value. Cast the value to the wider type before calling operator 'xxx' to avoid overflow(io.2).+#pragma warning (disable: 26812) // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).+#endif++// Clang/GCC warnings with -Weverything+#if defined(__clang__)+#if __has_warning("-Wunknown-warning-option")+#pragma clang diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx' // not all warnings are known by all Clang versions and they tend to be rename-happy.. so ignoring warnings triggers new warnings on some configuration. Great!+#endif+#pragma clang diagnostic ignored "-Wunknown-pragmas" // warning: unknown warning group 'xxx'+#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast // yes, they are more terse.+#pragma clang diagnostic ignored "-Wfloat-equal" // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants (typically 0.0f) is ok.+#pragma clang diagnostic ignored "-Wformat" // warning: format specifies type 'int' but the argument has type 'unsigned int'+#pragma clang diagnostic ignored "-Wformat-nonliteral" // warning: format string is not a string literal // passing non-literal to vsnformat(). yes, user passing incorrect format strings can crash the code.+#pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness+#pragma clang diagnostic ignored "-Wunused-macros" // warning: macro is not used // we define snprintf/vsnprintf on Windows so they are available, but not always used.+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" // warning: zero as null pointer constant // some standard header variations use #define NULL 0+#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 "-Wenum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_')+#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"// warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated+#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage" // warning: 'xxx' is an unsafe pointer used for buffer access+#pragma clang diagnostic ignored "-Wnontrivial-memaccess" // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type+#pragma clang diagnostic ignored "-Wswitch-default" // warning: 'switch' missing 'default' label+#elif defined(__GNUC__)+#pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind+#pragma GCC diagnostic ignored "-Wfloat-equal" // warning: comparing floating-point with '==' or '!=' is unsafe+#pragma GCC diagnostic ignored "-Wformat" // warning: format '%p' expects argument of type 'int'/'void*', but argument X has type 'unsigned int'/'ImGuiWindow*'+#pragma GCC diagnostic ignored "-Wformat-nonliteral" // warning: format not a string literal, format string not checked+#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated+#pragma GCC diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function+#pragma GCC diagnostic ignored "-Wstrict-overflow" // warning: assuming signed overflow does not occur when simplifying division / ..when changing X +- C1 cmp C2 to X cmp C2 -+ C1+#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+#pragma GCC diagnostic ignored "-Wcast-qual" // warning: cast from type 'const xxxx *' to type 'xxxx *' casts away qualifiers+#pragma GCC diagnostic ignored "-Wconversion" // warning: conversion to 'xxxx' from 'xxxx' may change value+#pragma GCC diagnostic ignored "-Wsign-conversion" // warning: conversion to 'xxxx' from 'xxxx' may change the sign of the result+#endif++//-------------------------------------------------------------------------+// Data+//-------------------------------------------------------------------------++// Widgets+static const float DRAGDROP_HOLD_TO_OPEN_TIMER = 0.70f; // Time for drag-hold to activate items accepting the ImGuiButtonFlags_PressedOnDragDropHold button behavior.+static const float DRAG_MOUSE_THRESHOLD_FACTOR = 0.50f; // Multiplier for the default value of io.MouseDragThreshold to make DragFloat/DragInt react faster to mouse drags.++// Those MIN/MAX values are not define because we need to point to them+static const signed char IM_S8_MIN = -128;+static const signed char IM_S8_MAX = 127;+static const unsigned char IM_U8_MIN = 0;+static const unsigned char IM_U8_MAX = 0xFF;+static const signed short IM_S16_MIN = -32768;+static const signed short IM_S16_MAX = 32767;+static const unsigned short IM_U16_MIN = 0;+static const unsigned short IM_U16_MAX = 0xFFFF;+static const ImS32 IM_S32_MIN = INT_MIN; // (-2147483647 - 1), (0x80000000);+static const ImS32 IM_S32_MAX = INT_MAX; // (2147483647), (0x7FFFFFFF)+static const ImU32 IM_U32_MIN = 0;+static const ImU32 IM_U32_MAX = UINT_MAX; // (0xFFFFFFFF)+#ifdef LLONG_MIN+static const ImS64 IM_S64_MIN = LLONG_MIN; // (-9223372036854775807ll - 1ll);+static const ImS64 IM_S64_MAX = LLONG_MAX; // (9223372036854775807ll);+#else+static const ImS64 IM_S64_MIN = -9223372036854775807LL - 1;+static const ImS64 IM_S64_MAX = 9223372036854775807LL;+#endif+static const ImU64 IM_U64_MIN = 0;+#ifdef ULLONG_MAX+static const ImU64 IM_U64_MAX = ULLONG_MAX; // (0xFFFFFFFFFFFFFFFFull);+#else+static const ImU64 IM_U64_MAX = (2ULL * 9223372036854775807LL + 1);+#endif++//-------------------------------------------------------------------------+// [SECTION] Forward Declarations+//-------------------------------------------------------------------------++// For InputTextEx()+static bool InputTextFilterCharacter(ImGuiContext* ctx, ImGuiInputTextState* state, unsigned int* p_char, ImGuiInputTextCallback callback, void* user_data, bool input_source_is_clipboard = false);+static ImVec2 InputTextCalcTextSize(ImGuiContext* ctx, const char* text_begin, const char* text_end_display, const char* text_end, const char** out_remaining = NULL, ImVec2* out_offset = NULL, ImDrawTextFlags flags = 0);++//-------------------------------------------------------------------------+// BUI: [SECTION] Blender widgets+//-------------------------------------------------------------------------+// BUI: This file is imgui_widgets.cpp (Dear ImGui 1.93.1 WIP) with Blender's widgets: every+// BUI edit is marked "BUI:". Item / ID / layout / navigation / text-editing logic is+// ImGui's; the rendering of widgets becomes draw-list callbacks (BKWidgetDraw, executed by+// the BUI backend with BK_draw_widget: the kit's own Blender widget drawing, Inter text by+// BUI) and, where Blender behaves differently, the interaction follows Blender+// (interface_handlers.cc). ImGui_ImplBUI_SetBlenderWidgets(false) restores ImGui's own+// drawing and interaction at runtime. See bindings/imgui/blender/README.md.++#include "BUI_kit.h" // BUI: BKWidgetDraw+#include "imgui_impl_bui.h" // BUI: ImGui_ImplBUI_DrawCallback_Widget++extern bool g_ImGui_ImplBUI_BlenderWidgets; // BUI: imgui_impl_bui.cpp++namespace // BUI+{++inline bool BuiOn() { return g_ImGui_ImplBUI_BlenderWidgets; }++// Corners for the next field of an aligned group (DragFloat3, ColorEdit components...).+int g_BuiNextCorners = 0;++ImVector<char> g_BuiPacket;++BKWidgetDraw BuiWidget(int kind, const ImRect& bb, int state)+{+ BKWidgetDraw w;+ memset(&w, 0, sizeof(w));+ w.kind = kind;+ w.state = state;+ w.corners = BK_CORNERS_ALL;+ w.align = -1;+ w.rect[0] = bb.Min.x;+ w.rect[1] = bb.Min.y;+ w.rect[2] = bb.GetWidth();+ w.rect[3] = bb.GetHeight();+ w.color[3] = -1.0f;+ return w;+}++void BuiSetTextRect(BKWidgetDraw& w, const ImVec2& pos, float width, float height)+{+ w.text_rect[0] = pos.x;+ w.text_rect[1] = pos.y;+ w.text_rect[2] = ImMax(width, 1.0f);+ w.text_rect[3] = height;+}++void BuiSetClip(BKWidgetDraw& w, const ImRect& clip)+{+ w.clip[0] = clip.Min.x;+ w.clip[1] = clip.Min.y;+ w.clip[2] = clip.Max.x;+ w.clip[3] = ImMax(clip.Max.y, clip.Min.y);+ if (w.clip[2] <= w.clip[0]) // empty: keep it empty, not "no clip"+ w.clip[2] = w.clip[0] + 0.001f, w.clip[3] = w.clip[1];+}++void BuiSetColor(BKWidgetDraw& w, ImU32 col)+{+ const ImVec4 c = ImGui::ColorConvertU32ToFloat4(col);+ w.color[0] = c.x; w.color[1] = c.y; w.color[2] = c.z; w.color[3] = c.w;+}++// Emits the widget into the current window's draw list: a BKWidgetDraw followed by its two texts.+void BuiEmit(BKWidgetDraw w, const char* text = NULL, const char* text_end = NULL, const char* text2 = NULL, const char* text2_end = NULL)+{+ ImGuiContext& g = *GImGui;+ ImDrawList* dl = g.CurrentWindow->DrawList;+ if (w.corners == BK_CORNERS_ALL && g_BuiNextCorners != 0 && (w.kind == BK_WIDGET_NUMBER || w.kind == BK_WIDGET_SLIDER || w.kind == BK_WIDGET_TEXT || w.kind == BK_WIDGET_BUTTON || w.kind == BK_WIDGET_MENU || w.kind == BK_WIDGET_SWATCH))+ w.corners = g_BuiNextCorners & BK_CORNERS_ALL;+ if (g.CurrentItemFlags & ImGuiItemFlags_Disabled)+ w.state |= BK_WS_DISABLED;+ const int n1 = text ? (int)((text_end ? text_end : text + ImStrlen(text)) - text) : 0;+ const int n2 = text2 ? (int)((text2_end ? text2_end : text2 + ImStrlen(text2)) - text2) : 0;+ w.text = w.text2 = NULL;+ g_BuiPacket.resize((int)sizeof(BKWidgetDraw) + n1 + n2 + 2);+ char* p = g_BuiPacket.Data;+ memcpy(p, &w, sizeof(w));+ p += sizeof(w);+ if (n1) memcpy(p, text, (size_t)n1);+ p[n1] = 0;+ p += n1 + 1;+ if (n2) memcpy(p, text2, (size_t)n2);+ p[n2] = 0;+ dl->AddCallback(ImGui_ImplBUI_DrawCallback_Widget, g_BuiPacket.Data, (size_t)g_BuiPacket.Size);+}++int BuiState(bool hovered, bool held)+{+ int s = 0;+ if (hovered)+ s |= BK_WS_HOVER;+ if (held && hovered)+ s |= BK_WS_PRESSED;+ return s;+}++// Text is drawn by BUI (Inter, like the kit's widgets) when ImGui uses Blender's font at its+// size; any other font or size keeps ImGui's own text rendering.+bool BuiTextOk()+{+ ImGuiContext& g = *GImGui;+ if (!BuiOn() || g.Font == NULL)+ return false;+ static ImFont* checked = NULL;+ static bool inter = false;+ if (g.Font != checked)+ {+ checked = g.Font;+ const char* name = g.Font->GetDebugName();+ inter = name != NULL && strstr(name, "Inter") != NULL;+ }+ return inter && ImFabs(g.FontSize - ImGui_ImplBUI_BlenderFontSize(BK_scale())) < 0.5f;+}++// One line of text at `pos` (ImGui's text top-left), in the current text color.+void BuiTextLine(ImDrawList* dl, ImVec2 pos, const char* s, const char* e, const ImRect* clip, ImU32 col)+{+ ImGuiContext& g = *GImGui;+ if (s == e || (col & IM_COL32_A_MASK) == 0)+ return;+ IM_UNUSED(dl);+ BKWidgetDraw w = BuiWidget(BK_WIDGET_LABEL, ImRect(pos, pos + ImVec2(1.0f, g.FontSize)), 0);+ BuiSetTextRect(w, pos, 1.0f, g.FontSize);+ BuiSetColor(w, col);+ w.align = 0;+ if (clip)+ BuiSetClip(w, *clip);+ // BUI: emitted into `dl`+ ImDrawList* saved = g.CurrentWindow->DrawList;+ g.CurrentWindow->DrawList = dl;+ BuiEmit(w, s, e);+ g.CurrentWindow->DrawList = saved;+}++void BuiTextLines(ImDrawList* dl, ImVec2 pos, const char* s, const char* e, const ImRect* clip, ImU32 col)+{+ ImGuiContext& g = *GImGui;+ while (s < e)+ {+ const char* le = (const char*)ImMemchr(s, '\n', e - s);+ if (!le)+ le = e;+ BuiTextLine(dl, pos, s, le, clip, col);+ pos.y += g.FontSize;+ s = le + 1;+ }+}++// Blender's drag-toggle (ui_drag_toggle_*): pressing a checkbox starts it; dragging over+// other checkboxes with the button held gives them the pressed one's new value.+struct BuiDragToggleState { ImGuiContext* Ctx; ImGuiID Owner; bool Active, Value; };+BuiDragToggleState g_BuiToggle = {};++void BuiDragToggle(ImGuiID id, const ImRect& bb, bool pressed, bool* checked)+{+ ImGuiContext& g = *GImGui;+ if (pressed && g.IO.MouseDown[0])+ {+ g_BuiToggle.Ctx = &g;+ g_BuiToggle.Owner = id;+ g_BuiToggle.Active = true;+ g_BuiToggle.Value = *checked;+ return;+ }+ if (!g_BuiToggle.Active || g_BuiToggle.Ctx != &g)+ return;+ if (!g.IO.MouseDown[0])+ {+ g_BuiToggle.Active = false;+ return;+ }+ if (id != g_BuiToggle.Owner && *checked != g_BuiToggle.Value && g.HoveredWindow == g.CurrentWindow && ImGui::IsMouseHoveringRect(bb.Min, bb.Max))+ *checked = g_BuiToggle.Value;+}++// Aligned groups (DragFloat3, SliderInt2, DragFloatRange2...): Blender joins the fields of a+// vector into one rounded row (UI_block_align): no gap, inner corners square.+float BuiAlignBegin(int components)+{+ ImGuiContext& g = *GImGui;+ if (!BuiOn() || components < 2)+ return -1.0f;+ const float spacing = g.Style.ItemInnerSpacing.x;+ g.Style.ItemInnerSpacing.x = 0.0f; // PushMultiItemsWidths() leaves no gaps+ return spacing;+}+void BuiAlignWidths(float spacing)+{+ if (spacing >= 0.0f)+ GImGui->Style.ItemInnerSpacing.x = spacing;+}+void BuiAlignItem(int i, int n)+{+ if (!BuiOn() || n < 2)+ return;+ g_BuiNextCorners = 0x100 | (i == 0 ? (1 | 8) : 0) | (i == n - 1 ? (2 | 4) : 0); // CNR_TL|BL, CNR_TR|BR+}+void BuiAlignEnd() { g_BuiNextCorners = 0; }++// Blender's backdrop for the current (popup / menu) window, drawn first in its draw list:+// over ImGui's own background, under the contents; unclipped so the shadow shows.+void BuiWindowBack(int kind, int state = 0)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* win = g.CurrentWindow;+ const ImRect vp = win->Viewport ? win->Viewport->GetMainRect() : ImRect(ImVec2(-FLT_MAX, -FLT_MAX), ImVec2(FLT_MAX, FLT_MAX));+ ImGui::PushClipRect(vp.Min, vp.Max, false);+ BKWidgetDraw w = BuiWidget(kind, win->Rect(), state);+ const ImGuiItemFlags backup = g.CurrentItemFlags;+ g.CurrentItemFlags &= ~ImGuiItemFlags_Disabled;+ BuiEmit(w);+ g.CurrentItemFlags = backup;+ ImGui::PopClipRect();+}++} // namespace (BUI)++// BUI: ImGui's text render helpers (imgui.cpp) replaced in this file by BUI text when+// BuiTextOk(); same signatures and defaults. (Text in imgui.cpp, e.g. window titles, stays+// ImGui's.)+static void BuiRenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true)+{+ if (!BuiTextOk())+ return ImGui::RenderText(pos, text, text_end, hide_text_after_hash);+ ImGuiContext& g = *GImGui;+ const char* end = hide_text_after_hash ? ImGui::FindRenderedTextEnd(text, text_end) : (text_end ? text_end : text + ImStrlen(text));+ if (text == end)+ return;+ BuiTextLines(g.CurrentWindow->DrawList, pos, text, end, NULL, ImGui::GetColorU32(ImGuiCol_Text));+ if (g.LogEnabled)+ ImGui::LogRenderedText(&pos, text, end);+}++static void BuiRenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)+{+ if (!BuiTextOk())+ return ImGui::RenderTextWrapped(pos, text, text_end, wrap_width);+ ImGuiContext& g = *GImGui;+ if (!text_end)+ text_end = text + ImStrlen(text);+ if (text == text_end)+ return;+ const ImU32 col = ImGui::GetColorU32(ImGuiCol_Text);+ ImDrawList* dl = g.CurrentWindow->DrawList;+ const float clip_y0 = dl->_CmdHeader.ClipRect.y, clip_y1 = dl->_CmdHeader.ClipRect.w;+ ImVec2 p = pos;+ const char* s = text;+ while (s < text_end)+ {+ // ImFont::RenderText's wrapping: break where ImGui's own font would+ const char* le = (const char*)ImMemchr(s, '\n', text_end - s);+ if (!le)+ le = text_end;+ const char* we = le;+ if (wrap_width > 0.0f)+ {+ we = ImFontCalcWordWrapPositionEx(g.Font, g.FontSize, s, le, wrap_width);+ if (we == s && s < le)+ we = s + 1; // at least one character per line+ }+ if (p.y + g.FontSize >= clip_y0 && p.y <= clip_y1)+ BuiTextLine(dl, p, s, we, NULL, col);+ p.y += g.FontSize;+ s = we;+ if (s < text_end && *s == '\n')+ s++;+ else+ while (s < le && (*s == ' ' || *s == '\t')) // skip blanks at the start of a wrapped line+ s++;+ }+ if (g.LogEnabled)+ ImGui::LogRenderedText(&pos, text, text_end);+}++static void BuiRenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_display_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL)+{+ if (!BuiTextOk())+ return ImGui::RenderTextClippedEx(draw_list, pos_min, pos_max, text, text_display_end, text_size_if_known, align, clip_rect);+ ImVec2 pos = pos_min;+ const ImVec2 text_size = text_size_if_known ? *text_size_if_known : ImGui::CalcTextSize(text, text_display_end, false, 0.0f);+ const ImVec2* clip_min = clip_rect ? &clip_rect->Min : &pos_min;+ const ImVec2* clip_max = clip_rect ? &clip_rect->Max : &pos_max;+ bool need_clipping = (pos.x + text_size.x >= clip_max->x) || (pos.y + text_size.y >= clip_max->y);+ if (clip_rect)+ need_clipping |= (pos.x < clip_min->x) || (pos.y < clip_min->y);+ if (align.x > 0.0f) pos.x = ImMax(pos.x, pos.x + (pos_max.x - pos.x - text_size.x) * align.x);+ if (align.y > 0.0f) pos.y = ImMax(pos.y, pos.y + (pos_max.y - pos.y - text_size.y) * align.y);+ const ImRect clip(*clip_min, *clip_max);+ BuiTextLines(draw_list, pos, text, text_display_end ? text_display_end : text + ImStrlen(text), need_clipping ? &clip : NULL, ImGui::GetColorU32(ImGuiCol_Text));+}++static void BuiRenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL)+{+ if (!BuiTextOk())+ return ImGui::RenderTextClipped(pos_min, pos_max, text, text_end, text_size_if_known, align, clip_rect);+ const char* text_display_end = ImGui::FindRenderedTextEnd(text, text_end);+ if (text_display_end == text)+ return;+ ImGuiContext& g = *GImGui;+ BuiRenderTextClippedEx(g.CurrentWindow->DrawList, pos_min, pos_max, text, text_display_end, text_size_if_known, align, clip_rect);+ if (g.LogEnabled)+ ImGui::LogRenderedText(&pos_min, text, text_display_end);+}++static void BuiRenderTextEllipsis(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, float ellipsis_max_x, const char* text, const char* text_end_full, const ImVec2* text_size_if_known)+{+ if (!BuiTextOk())+ return ImGui::RenderTextEllipsis(draw_list, pos_min, pos_max, ellipsis_max_x, text, text_end_full, text_size_if_known);+ ImGuiContext& g = *GImGui;+ if (text_end_full == NULL)+ text_end_full = ImGui::FindRenderedTextEnd(text);+ const ImVec2 text_size = text_size_if_known ? *text_size_if_known : ImGui::CalcTextSize(text, text_end_full, false, 0.0f);+ if (text_size.x > pos_max.x - pos_min.x)+ {+ // "Hello wo…": the part that fits before the ellipsis, as ImGui measures it+ ImFont* font = draw_list->_Data->Font;+ const float font_size = draw_list->_Data->FontSize;+ const char* text_end_ellipsis = NULL;+ const float ellipsis_width = BK_text_width("\xe2\x80\xa6", 3);+ const float text_avail_width = ImMax((ImMax(pos_max.x, ellipsis_max_x) - ellipsis_width) - pos_min.x, 1.0f);+ font->CalcTextSizeA(font_size, text_avail_width, 0.0f, text, text_end_full, &text_end_ellipsis);+ static ImGuiTextBuffer buf;+ buf.Buf.resize(0);+ buf.append(text, text_end_ellipsis);+ buf.append("\xe2\x80\xa6");+ const ImRect clip(pos_min, ImVec2(ImMax(pos_max.x, ellipsis_max_x), pos_max.y));+ BuiTextLine(draw_list, pos_min, buf.begin(), buf.end(), &clip, ImGui::GetColorU32(ImGuiCol_Text));+ }+ else+ {+ BuiRenderTextClippedEx(draw_list, pos_min, pos_max, text, text_end_full, &text_size, ImVec2(0.0f, 0.0f));+ }+ if (g.LogEnabled)+ ImGui::LogRenderedText(&pos_min, text, text_end_full);+}++#define RenderText(...) BuiRenderText(__VA_ARGS__) // BUI+#define RenderTextWrapped(...) BuiRenderTextWrapped(__VA_ARGS__) // BUI+#define RenderTextClipped(...) BuiRenderTextClipped(__VA_ARGS__) // BUI+#define RenderTextClippedEx(...) BuiRenderTextClippedEx(__VA_ARGS__) // BUI+#define RenderTextEllipsis(...) BuiRenderTextEllipsis(__VA_ARGS__) // BUI++//-------------------------------------------------------------------------+// [SECTION] Widgets: Text, etc.+//-------------------------------------------------------------------------+// - TextEx() [Internal]+// - TextUnformatted()+// - Text()+// - TextV()+// - TextColored()+// - TextColoredV()+// - TextDisabled()+// - TextDisabledV()+// - TextWrapped()+// - TextWrappedV()+// - LabelText()+// - LabelTextV()+// - BulletText()+// - BulletTextV()+//-------------------------------------------------------------------------++void ImGui::TextEx(const char* text, const char* text_end, ImGuiTextFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;+ ImGuiContext& g = *GImGui;++ // Accept null ranges+ if (text == text_end)+ text = text_end = "";++ // Calculate length+ const char* text_begin = text;+ if (text_end == NULL)+ text_end = text + ImStrlen(text); // FIXME-OPT++ const ImVec2 text_pos(window->DC.CursorPos.x, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);+ const float wrap_pos_x = window->DC.TextWrapPos;+ const bool wrap_enabled = (wrap_pos_x >= 0.0f);+ if (text_end - text <= 2000 || wrap_enabled)+ {+ // Common case+ const float wrap_width = wrap_enabled ? CalcWrapWidthForPos(window->DC.CursorPos, wrap_pos_x) : 0.0f;+ const ImVec2 text_size = CalcTextSize(text_begin, text_end, false, wrap_width);++ ImRect bb(text_pos, text_pos + text_size);+ ItemSize(text_size, 0.0f);+ if (!ItemAdd(bb, 0))+ return;++ // Render (we don't hide text after ## in this end-user function)+ RenderTextWrapped(bb.Min, text_begin, text_end, wrap_width);+ }+ else+ {+ // Long text!+ // Perform manual coarse clipping to optimize for long multi-line text+ // - From this point we will only compute the width of lines that are visible. Optimization only available when word-wrapping is disabled.+ // - We also don't vertically center the text within the line full height, which is unlikely to matter because we are likely the biggest and only item on the line.+ // - We use memchr(), pay attention that well optimized versions of those str/mem functions are much faster than a casually written loop.+ const char* line = text;+ const float line_height = GetTextLineHeight();+ ImVec2 text_size(0, 0);++ // Lines to skip (can't skip when logging text)+ ImVec2 pos = text_pos;+ if (!g.LogEnabled)+ {+ int lines_skippable = (int)((window->ClipRect.Min.y - text_pos.y) / line_height);+ if (lines_skippable > 0)+ {+ int lines_skipped = 0;+ while (line < text_end && lines_skipped < lines_skippable)+ {+ const char* line_end = (const char*)ImMemchr(line, '\n', text_end - line);+ if (!line_end)+ line_end = text_end;+ if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)+ text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);+ line = line_end + 1;+ lines_skipped++;+ }+ pos.y += lines_skipped * line_height;+ }+ }++ // Lines to render+ if (line < text_end)+ {+ ImRect line_rect(pos, pos + ImVec2(FLT_MAX, line_height));+ while (line < text_end)+ {+ if (IsClippedEx(line_rect, 0))+ break;++ const char* line_end = (const char*)ImMemchr(line, '\n', text_end - line);+ if (!line_end)+ line_end = text_end;+ text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);+ RenderText(pos, line, line_end, false);+ line = line_end + 1;+ line_rect.Min.y += line_height;+ line_rect.Max.y += line_height;+ pos.y += line_height;+ }++ // Count remaining lines+ int lines_skipped = 0;+ while (line < text_end)+ {+ const char* line_end = (const char*)ImMemchr(line, '\n', text_end - line);+ if (!line_end)+ line_end = text_end;+ if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)+ text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);+ line = line_end + 1;+ lines_skipped++;+ }+ pos.y += lines_skipped * line_height;+ }+ text_size.y = (pos - text_pos).y;++ ImRect bb(text_pos, text_pos + text_size);+ ItemSize(text_size, 0.0f);+ ItemAdd(bb, 0);+ }+}++// Note that all functions taking format strings in the API may be passed ("%s", text) or ("%.*s", text_len, text),+// which will automatically bypass the formatter.+void ImGui::TextUnformatted(const char* text, const char* text_end)+{+ TextEx(text, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);+}++void ImGui::Text(const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ TextV(fmt, args);+ va_end(args);+}++void ImGui::TextV(const char* fmt, va_list args)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ const char* text, *text_end;+ ImFormatStringToTempBufferV(&text, &text_end, fmt, args);+ TextEx(text, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);+}++void ImGui::TextColored(const ImVec4& col, const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ TextColoredV(col, fmt, args);+ va_end(args);+}++void ImGui::TextColoredV(const ImVec4& col, const char* fmt, va_list args)+{+ PushStyleColor(ImGuiCol_Text, col);+ TextV(fmt, args);+ PopStyleColor();+}++void ImGui::TextDisabled(const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ TextDisabledV(fmt, args);+ va_end(args);+}++void ImGui::TextDisabledV(const char* fmt, va_list args)+{+ ImGuiContext& g = *GImGui;+ PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);+ TextV(fmt, args);+ PopStyleColor();+}++void ImGui::TextWrapped(const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ TextWrappedV(fmt, args);+ va_end(args);+}++void ImGui::TextWrappedV(const char* fmt, va_list args)+{+ ImGuiContext& g = *GImGui;+ const bool need_backup = (g.CurrentWindow->DC.TextWrapPos < 0.0f); // Keep existing wrap position if one is already set+ if (need_backup)+ PushTextWrapPos(0.0f);+ TextV(fmt, args);+ if (need_backup)+ PopTextWrapPos();+}++void ImGui::TextAligned(float align_x, float width, const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ TextAlignedV(align_x, width, fmt, args);+ va_end(args);+}++// align_x: 0.0f = left, 0.5f = center, 1.0f = right.+// width < 0.0f (e.g. -FLT_MIN): shortcut for GetContentRegionAvail().x+// FIXME-WIP: Works but API is likely to be reworked. This is designed for 1 item on the line. (#7024, #9455)+void ImGui::TextAlignedV(float align_x, float width, const char* fmt, va_list args)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ const char* text, *text_end;+ ImFormatStringToTempBufferV(&text, &text_end, fmt, args);+ const ImVec2 text_size = CalcTextSize(text, text_end);++ const ImVec2 size = CalcItemSize(ImVec2(width, 0.0f), 0.0f, text_size.y);+ ImVec2 pos(window->DC.CursorPos.x, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);+ ImVec2 pos_max(pos.x + size.x, window->ClipRect.Max.y);++ window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, pos.x + text_size.x);+ window->DC.IdealMaxPos.x = ImMax(window->DC.IdealMaxPos.x, pos.x + text_size.x);+ const ImVec2 backup_max_pos = window->DC.CursorMaxPos;+ ItemSize(size);+ const bool is_visible = ItemAdd(ImRect(pos, pos + size), 0);+ window->DC.CursorMaxPos.x = backup_max_pos.x; // Cancel out extending content to 'size' to use 'text_size' allowing auto-resize to function with align_x > 0.0f+ if (!is_visible)+ return;++ if (align_x > 0.0f && text_size.x < size.x)+ pos.x += ImTrunc((size.x - text_size.x) * align_x);+ RenderTextEllipsis(window->DrawList, pos, pos_max, pos_max.x, text, text_end, &text_size);++ if (size.x < text_size.x && IsItemHovered(ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_ForTooltip))+ SetTooltip("%.*s", (int)(text_end - text), text);+}++void ImGui::LabelText(const char* label, const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ LabelTextV(label, fmt, args);+ va_end(args);+}++// Add a label+text combo aligned to other label+value widgets+void ImGui::LabelTextV(const char* label, const char* fmt, va_list args)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const float w = CalcItemWidth();++ const char* value_text_begin, *value_text_end;+ ImFormatStringToTempBufferV(&value_text_begin, &value_text_end, fmt, args);+ const ImVec2 value_size = CalcTextSize(value_text_begin, value_text_end, false);+ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);++ const ImVec2 pos = window->DC.CursorPos;+ const ImRect value_bb(pos, pos + ImVec2(w, value_size.y + style.FramePadding.y * 2));+ const ImRect total_bb(pos, pos + ImVec2(w + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), ImMax(value_size.y, label_size.y) + style.FramePadding.y * 2));+ ItemSize(total_bb, style.FramePadding.y);+ if (!ItemAdd(total_bb, 0))+ return;++ // Render+ RenderTextClipped(value_bb.Min + style.FramePadding, value_bb.Max, value_text_begin, value_text_end, &value_size, ImVec2(0.0f, 0.0f));+ if (label_size.x > 0.0f)+ RenderText(ImVec2(value_bb.Max.x + style.ItemInnerSpacing.x, value_bb.Min.y + style.FramePadding.y), label, label_end, false);+}++void ImGui::BulletText(const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ BulletTextV(fmt, args);+ va_end(args);+}++// Text with a little bullet aligned to the typical tree node.+void ImGui::BulletTextV(const char* fmt, va_list args)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;++ const char* text_begin, *text_end;+ ImFormatStringToTempBufferV(&text_begin, &text_end, fmt, args);+ const ImVec2 label_size = CalcTextSize(text_begin, text_end, false);+ const ImVec2 total_size = ImVec2(g.FontSize + (label_size.x > 0.0f ? (label_size.x + style.FramePadding.x * 2) : 0.0f), label_size.y); // Empty text doesn't add padding+ ImVec2 pos = window->DC.CursorPos;+ pos.y += window->DC.CurrLineTextBaseOffset;+ ItemSize(total_size, 0.0f);+ const ImRect bb(pos, pos + total_size);+ if (!ItemAdd(bb, 0))+ return;++ // Render+ ImU32 text_col = GetColorU32(ImGuiCol_Text);+ RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, g.FontSize * 0.5f), text_col);+ RenderText(bb.Min + ImVec2(g.FontSize + style.FramePadding.x * 2, 0.0f), text_begin, text_end, false);+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: Main+//-------------------------------------------------------------------------+// - ButtonBehavior() [Internal]+// - Button()+// - SmallButton()+// - InvisibleButton()+// - ArrowButton()+// - CloseButton() [Internal]+// - CollapseButton() [Internal]+// - GetWindowScrollbarID() [Internal]+// - GetWindowScrollbarRect() [Internal]+// - Scrollbar() [Internal]+// - ScrollbarEx() [Internal]+// - Image()+// - ImageButton()+// - Checkbox()+// - CheckboxFlagsT() [Internal]+// - CheckboxFlags()+// - RadioButton()+// - ProgressBar()+// - Bullet()+// - Hyperlink()+//-------------------------------------------------------------------------++// The ButtonBehavior() function is key to many interactions and used by many/most widgets.+// Because we handle so many cases (keyboard/gamepad navigation, drag and drop) and many specific behavior (via ImGuiButtonFlags_),+// this code is a little complex.+// By far the most common path is interacting with the Mouse using the default ImGuiButtonFlags_PressedOnClickRelease button behavior.+// See the series of events below and the corresponding state reported by dear imgui:+//------------------------------------------------------------------------------------------------------------------------------------------------+// with PressedOnClickRelease: return-value IsItemHovered() IsItemActive() IsItemActivated() IsItemDeactivated() IsItemClicked()+// Frame N+0 (mouse is outside bb) - - - - - -+// Frame N+1 (mouse moves inside bb) - true - - - -+// Frame N+2 (mouse button is down) - true true true - true+// Frame N+3 (mouse button is down) - true true - - -+// Frame N+4 (mouse moves outside bb) - - true - - -+// Frame N+5 (mouse moves inside bb) - true true - - -+// Frame N+6 (mouse button is released) true true - - true -+// Frame N+7 (mouse button is released) - true - - - -+// Frame N+8 (mouse moves outside bb) - - - - - -+//------------------------------------------------------------------------------------------------------------------------------------------------+// with PressedOnClick: return-value IsItemHovered() IsItemActive() IsItemActivated() IsItemDeactivated() IsItemClicked()+// Frame N+2 (mouse button is down) true true true true - true+// Frame N+3 (mouse button is down) - true true - - -+// Frame N+6 (mouse button is released) - true - - true -+// Frame N+7 (mouse button is released) - true - - - -+//------------------------------------------------------------------------------------------------------------------------------------------------+// with PressedOnRelease: return-value IsItemHovered() IsItemActive() IsItemActivated() IsItemDeactivated() IsItemClicked()+// Frame N+2 (mouse button is down) - true - - - true+// Frame N+3 (mouse button is down) - true - - - -+// Frame N+6 (mouse button is released) true true - - - -+// Frame N+7 (mouse button is released) - true - - - -+//------------------------------------------------------------------------------------------------------------------------------------------------+// with PressedOnDoubleClick: return-value IsItemHovered() IsItemActive() IsItemActivated() IsItemDeactivated() IsItemClicked()+// Frame N+0 (mouse button is down) - true - - - true+// Frame N+1 (mouse button is down) - true - - - -+// Frame N+2 (mouse button is released) - true - - - -+// Frame N+3 (mouse button is released) - true - - - -+// Frame N+4 (mouse button is down) true true true true - true+// Frame N+5 (mouse button is down) - true true - - -+// Frame N+6 (mouse button is released) - true - - true -+// Frame N+7 (mouse button is released) - true - - - -+//------------------------------------------------------------------------------------------------------------------------------------------------+// Note that some combinations are supported,+// - PressedOnDragDropHold can generally be associated with any flag.+// - PressedOnDoubleClick can be associated by PressedOnClickRelease/PressedOnRelease, in which case the second release event won't be reported.+//------------------------------------------------------------------------------------------------------------------------------------------------+// The behavior of the return-value changes when ImGuiItemFlags_ButtonRepeat is set:+// Repeat+ Repeat+ Repeat+ Repeat++// PressedOnClickRelease PressedOnClick PressedOnRelease PressedOnDoubleClick+//-------------------------------------------------------------------------------------------------------------------------------------------------+// Frame N+0 (mouse button is down) - true - true+// ... - - - -+// Frame N + RepeatDelay true true - true+// ... - - - -+// Frame N + RepeatDelay + RepeatRate*N true true - true+//-------------------------------------------------------------------------------------------------------------------------------------------------++// - FIXME: For refactor we could output flags, incl mouse hovered vs nav keyboard vs nav triggered etc.+// And better standardize how widgets use 'GetColor32((held && hovered) ? ... : hovered ? ...)' vs 'GetColor32(held ? ... : hovered ? ...);'+// For mouse feedback we typically prefer the 'held && hovered' test, but for nav feedback not always. Outputting hovered=true on Activation may be misleading.+// - Since v1.91.2 (Sept 2024) we included io.ConfigDebugHighlightIdConflicts feature.+// One idiom which was previously valid which will now emit a warning is when using multiple overlaid ButtonBehavior()+// with same ID and different MouseButton (see #8030). You can fix it by:+// (1) switching to use a single ButtonBehavior() with multiple _MouseButton flags.+// or (2) surrounding those calls with PushItemFlag(ImGuiItemFlags_AllowDuplicateId, true); ... PopItemFlag()+bool ImGui::ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();++ // Default behavior inherited from item flags+ // Note that _both_ ButtonFlags and ItemFlags are valid sources, so copy one into the item_flags and only check that.+ ImGuiItemFlags item_flags = (g.LastItemData.ID == id ? g.LastItemData.ItemFlags : g.CurrentItemFlags);+ if (flags & ImGuiButtonFlags_AllowOverlap)+ item_flags |= ImGuiItemFlags_AllowOverlap;+ if (item_flags & ImGuiItemFlags_NoFocus)+ flags |= ImGuiButtonFlags_NoFocus | ImGuiButtonFlags_NoNavFocus;++ // Default only reacts to left mouse button+ if ((flags & ImGuiButtonFlags_MouseButtonMask_) == 0)+ flags |= ImGuiButtonFlags_MouseButtonLeft;++ // Default behavior requires click + release inside bounding box+ if ((flags & ImGuiButtonFlags_PressedOnMask_) == 0)+ flags |= (item_flags & ImGuiItemFlags_ButtonRepeat) ? ImGuiButtonFlags_PressedOnClick : ImGuiButtonFlags_PressedOnDefault_;++ ImGuiWindow* backup_hovered_window = g.HoveredWindow;+ const bool flatten_hovered_children = (flags & ImGuiButtonFlags_FlattenChildren) && g.HoveredWindow && g.HoveredWindow->RootWindow == window->RootWindow;+ if (flatten_hovered_children)+ g.HoveredWindow = window;++#ifdef IMGUI_ENABLE_TEST_ENGINE+ // Alternate registration spot, for when caller didn't use ItemAdd()+ if (g.LastItemData.ID != id)+ IMGUI_TEST_ENGINE_ITEM_ADD(id, bb, NULL);+#endif++ bool pressed = false;+ bool hovered = ItemHoverable(bb, id, item_flags);++ // Special mode for Drag and Drop used by openables (tree nodes, tabs etc.)+ // where holding the button pressed for a long time while drag a payload item triggers the button.+ if (g.DragDropActive)+ {+ if ((flags & ImGuiButtonFlags_PressedOnDragDropHold) && !(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoHoldToOpenOthers) && IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))+ {+ hovered = true;+ SetHoveredID(id);+ if (g.HoveredIdTimer - g.IO.DeltaTime <= DRAGDROP_HOLD_TO_OPEN_TIMER && g.HoveredIdTimer >= DRAGDROP_HOLD_TO_OPEN_TIMER)+ {+ pressed = true;+ g.DragDropHoldJustPressedId = id;+ FocusWindow(window);+ }+ }+ if (g.DragDropAcceptIdPrev == id && (g.DragDropAcceptFlagsPrev & ImGuiDragDropFlags_AcceptDrawAsHovered))+ hovered = true;+ }++ if (flatten_hovered_children)+ g.HoveredWindow = backup_hovered_window;++ // Mouse handling+ const ImGuiID test_owner_id = (flags & ImGuiButtonFlags_NoTestKeyOwner) ? ImGuiKeyOwner_Any : id;+ if (hovered)+ {+ IM_ASSERT(id != 0); // Lazily check inside rare path.++ // Poll mouse buttons+ // - 'mouse_button_clicked' is generally carried into ActiveIdMouseButton when setting ActiveId.+ // - Technically we only need some values in one code path, but since this is gated by hovered test this is fine.+ int mouse_button_clicked = -1;+ int mouse_button_released = -1;+ for (int button = 0; button < 3; button++)+ if (flags & (ImGuiButtonFlags_MouseButtonLeft << button)) // Handle ImGuiButtonFlags_MouseButtonRight and ImGuiButtonFlags_MouseButtonMiddle here.+ {+ if (IsMouseClicked(button, ImGuiInputFlags_None, test_owner_id) && mouse_button_clicked == -1) { mouse_button_clicked = button; }+ if (IsMouseReleased(button, test_owner_id) && mouse_button_released == -1) { mouse_button_released = button; }+ }++ // Process initial action+ const bool mods_ok = !(flags & ImGuiButtonFlags_NoKeyModsAllowed) || (!g.IO.KeyCtrl && !g.IO.KeyShift && !g.IO.KeyAlt);+ if (mods_ok)+ {+ if (mouse_button_clicked != -1 && g.ActiveId != id)+ {+ if (!(flags & ImGuiButtonFlags_NoSetKeyOwner))+ SetKeyOwner(MouseButtonToKey(mouse_button_clicked), id);+ if (flags & (ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere))+ {+ SetActiveID(id, window);+ g.ActiveIdMouseButton = (ImS8)mouse_button_clicked;+ if (!(flags & ImGuiButtonFlags_NoNavFocus))+ {+ SetFocusID(id, window);+ FocusWindow(window);+ }+ else if (!(flags & ImGuiButtonFlags_NoFocus))+ {+ FocusWindow(window, ImGuiFocusRequestFlags_RestoreFocusedChild); // Still need to focus and bring to front, but try to avoid losing NavId when navigating a child+ }+ }+ if ((flags & ImGuiButtonFlags_PressedOnClick) || ((flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseClickedCount[mouse_button_clicked] == 2))+ {+ pressed = true;+ if (flags & ImGuiButtonFlags_NoHoldingActiveId)+ ClearActiveID();+ else+ SetActiveID(id, window); // Hold on ID+ g.ActiveIdMouseButton = (ImS8)mouse_button_clicked;+ if (!(flags & ImGuiButtonFlags_NoNavFocus))+ {+ SetFocusID(id, window);+ FocusWindow(window);+ }+ else if (!(flags & ImGuiButtonFlags_NoFocus))+ {+ FocusWindow(window, ImGuiFocusRequestFlags_RestoreFocusedChild); // Still need to focus and bring to front, but try to avoid losing NavId when navigating a child+ }+ }+ if (flags & ImGuiButtonFlags_PressedOnRelease)+ {+ // FIXME: Traditionally ImGuiButtonFlags_PressedOnRelease never took ActiveId. Adding it in 2026-03-20 since ImGuiButtonFlags_NoHoldingActiveId can always be added.+ // We don't yet perform an explicit ClearActiveID() to reduce scope of change, but this possibility could be investigated.+ if (!(flags & ImGuiButtonFlags_NoHoldingActiveId))+ SetActiveID(id, window); // Hold on ID+ g.ActiveIdMouseButton = (ImS8)mouse_button_clicked;+ }+ }+ if (flags & ImGuiButtonFlags_PressedOnRelease)+ {+ if (mouse_button_released != -1)+ {+ const bool has_repeated_at_least_once = (item_flags & ImGuiItemFlags_ButtonRepeat) && g.IO.MouseDownDurationPrev[mouse_button_released] >= g.IO.KeyRepeatDelay; // Repeat mode trumps on release behavior+ if (!has_repeated_at_least_once)+ pressed = true;+ if (!(flags & ImGuiButtonFlags_NoNavFocus))+ SetFocusID(id, window); // FIXME: Lack of FocusWindow() call here is inconsistent with other paths. Research why.+ ClearActiveID();+ }+ }++ // 'Repeat' mode acts when held regardless of _PressedOn flags (see table above).+ // Relies on repeat logic of IsMouseClicked() but we may as well do it ourselves if we end up exposing finer RepeatDelay/RepeatRate settings.+ if (g.ActiveId == id && (item_flags & ImGuiItemFlags_ButtonRepeat))+ if (g.IO.MouseDownDuration[g.ActiveIdMouseButton] > 0.0f && IsMouseClicked(g.ActiveIdMouseButton, ImGuiInputFlags_Repeat, test_owner_id))+ pressed = true;+ }++ if (pressed && g.IO.ConfigNavCursorVisibleAuto)+ g.NavCursorVisible = false;+ }++ // Keyboard/Gamepad navigation handling+ // We report navigated and navigation-activated items as hovered but we don't set g.HoveredId to not interfere with mouse.+ if ((item_flags & ImGuiItemFlags_Disabled) == 0)+ {+ if (g.NavId == id && g.NavCursorVisible && g.NavHighlightItemUnderNav)+ if (!(flags & ImGuiButtonFlags_NoHoveredOnFocus))+ hovered = true;+ if (g.NavActivateDownId == id)+ {+ bool nav_activated_by_code = (g.NavActivateId == id);+ bool nav_activated_by_inputs = (g.NavActivatePressedId == id);+ if (!nav_activated_by_inputs && (item_flags & ImGuiItemFlags_ButtonRepeat))+ {+ // Avoid pressing multiple keys from triggering excessive amount of repeat events+ const ImGuiKeyData* key1 = GetKeyData(ImGuiKey_Space);+ const ImGuiKeyData* key2 = GetKeyData(ImGuiKey_Enter);+ const ImGuiKeyData* key3 = GetKeyData(ImGuiKey_NavGamepadActivate);+ const float t1 = ImMax(ImMax(key1->DownDuration, key2->DownDuration), key3->DownDuration);+ nav_activated_by_inputs = CalcTypematicRepeatAmount(t1 - g.IO.DeltaTime, t1, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate) > 0;+ }+ if (nav_activated_by_code || nav_activated_by_inputs)+ {+ // Set active id so it can be queried by user via IsItemActive(), equivalent of holding the mouse button.+ pressed = true;+ SetActiveID(id, window);+ g.ActiveIdSource = g.NavInputSource;+ if (!(flags & ImGuiButtonFlags_NoNavFocus) && !(g.NavActivateFlags & ImGuiActivateFlags_FromShortcut))+ SetFocusID(id, window);+ if (g.NavActivateFlags & ImGuiActivateFlags_FromShortcut)+ g.ActiveIdFromShortcut = true;+ }+ }+ }++ // Process while held+ bool held = false;+ if (g.ActiveId == id)+ {+ if (g.ActiveIdSource == ImGuiInputSource_Mouse)+ {+ if (g.ActiveIdIsJustActivated)+ g.ActiveIdClickOffset = g.IO.MousePos - bb.Min;++ const int mouse_button = g.ActiveIdMouseButton;+ if (mouse_button == -1)+ {+ // Fallback for the rare situation were g.ActiveId was set programmatically or from another widget (e.g. #6304).+ ClearActiveID();+ }+ else if (IsMouseDown(mouse_button, test_owner_id))+ {+ held = true;+ }+ else+ {+ bool release_in = hovered && (flags & ImGuiButtonFlags_PressedOnClickRelease) != 0;+ bool release_anywhere = (flags & ImGuiButtonFlags_PressedOnClickReleaseAnywhere) != 0;+ if ((release_in || release_anywhere) && !g.DragDropActive)+ {+ // Report as pressed when releasing the mouse (this is the most common path)+ bool is_double_click_release = (flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseReleased[mouse_button] && g.IO.MouseClickedLastCount[mouse_button] == 2;+ bool is_repeating_already = (item_flags & ImGuiItemFlags_ButtonRepeat) && g.IO.MouseDownDurationPrev[mouse_button] >= g.IO.KeyRepeatDelay; // Repeat mode trumps <on release>+ bool is_button_avail_or_owned = TestKeyOwner(MouseButtonToKey(mouse_button), test_owner_id);+ if (!is_double_click_release && !is_repeating_already && is_button_avail_or_owned)+ pressed = true;+ }+ ClearActiveID();+ }+ if (!(flags & ImGuiButtonFlags_NoNavFocus) && g.IO.ConfigNavCursorVisibleAuto)+ g.NavCursorVisible = false;+ }+ else if (g.ActiveIdSource == ImGuiInputSource_Keyboard || g.ActiveIdSource == ImGuiInputSource_Gamepad)+ {+ // When activated using Nav, we hold on the ActiveID until activation button is released+ if (g.NavActivateDownId == id)+ held = true; // hovered == true not true as we are already likely hovered on direct activation.+ else+ ClearActiveID();+ }+ if (pressed)+ g.ActiveIdHasBeenPressedBefore = true;+ }++ // Activation highlight (this may be a remote activation)+ if (g.NavHighlightActivatedId == id && (item_flags & ImGuiItemFlags_Disabled) == 0)+ hovered = true;++ if (out_hovered) *out_hovered = hovered;+ if (out_held) *out_held = held;++ return pressed;+}++bool ImGui::ButtonEx(const char* label, const ImVec2& size_arg, ImGuiButtonFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);+ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);++ ImVec2 pos = window->DC.CursorPos;+ if ((flags & ImGuiButtonFlags_AlignTextBaseLine) && style.FramePadding.y < window->DC.CurrLineTextBaseOffset) // Try to vertically align buttons that are smaller/have no padding so that text baseline matches (bit hacky, since it shouldn't be a flag)+ pos.y += window->DC.CurrLineTextBaseOffset - style.FramePadding.y;+ ImVec2 size = CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);++ const ImRect bb(pos, pos + size);+ ItemSize(size, style.FramePadding.y);+ if (!ItemAdd(bb, id))+ return false;++ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);++ // Render+ const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);+ RenderNavCursor(bb, id);+ if (BuiOn()) // BUI: Blender push button (button_draw): wcol_regular, pressed = inner_sel+ {+ const bool centered = style.ButtonTextAlign.x == 0.5f && style.ButtonTextAlign.y == 0.5f && BuiTextOk() && label_size.x <= bb.GetWidth();+ BuiEmit(BuiWidget(BK_WIDGET_BUTTON, bb, BuiState(hovered, held)), centered ? label : NULL, label_end);+ if (centered)+ {+ if (g.LogEnabled)+ LogRenderedText(&bb.Min, label, label_end);+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return pressed;+ }+ }+ else // BUI+ RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);++ if (g.LogEnabled)+ LogSetNextTextDecoration("[", "]");+ RenderTextClipped(bb.Min + style.FramePadding, bb.Max - style.FramePadding, label, label_end, &label_size, style.ButtonTextAlign, &bb);++ // Automatically close popups+ //if (pressed && !(flags & ImGuiButtonFlags_DontClosePopups) && (window->Flags & ImGuiWindowFlags_Popup))+ // CloseCurrentPopup();++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return pressed;+}++bool ImGui::Button(const char* label, const ImVec2& size_arg)+{+ return ButtonEx(label, size_arg, ImGuiButtonFlags_None);+}++// Small buttons fits within text without additional vertical spacing.+bool ImGui::SmallButton(const char* label)+{+ ImGuiContext& g = *GImGui;+ float backup_padding_y = g.Style.FramePadding.y;+ g.Style.FramePadding.y = 0.0f;+ bool pressed = ButtonEx(label, ImVec2(0, 0), ImGuiButtonFlags_AlignTextBaseLine);+ g.Style.FramePadding.y = backup_padding_y;+ return pressed;+}++// Tip: use ImGui::PushID()/PopID() to push indices or pointers in the ID stack.+// Then you can keep 'str_id' empty or the same for all your buttons (instead of creating a string based on a non-string id)+bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg, ImGuiButtonFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ // Ensure zero-size fits to contents+ ImVec2 size = CalcItemSize(ImVec2(size_arg.x != 0.0f ? size_arg.x : -FLT_MIN, size_arg.y != 0.0f ? size_arg.y : -FLT_MIN), 0.0f, 0.0f);++ const ImGuiID id = window->GetID(str_id);+ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);+ ItemSize(size);+ if (!ItemAdd(bb, id, NULL, (flags & ImGuiButtonFlags_EnableNav) ? ImGuiItemFlags_None : ImGuiItemFlags_NoNav))+ return false;++ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);+ RenderNavCursor(bb, id);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, str_id, g.LastItemData.StatusFlags);+ return pressed;+}++bool ImGui::ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size, ImGuiButtonFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ const ImGuiID id = window->GetID(str_id);+ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);+ const float default_size = GetFrameHeight();+ ItemSize(size, (size.y >= default_size) ? g.Style.FramePadding.y : -1.0f);+ if (!ItemAdd(bb, id))+ return false;++ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);++ // Render+ const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);+ const ImU32 text_col = GetColorU32(ImGuiCol_Text);+ RenderNavCursor(bb, id);+ if (BuiOn()) // BUI: Blender push button with a triangle+ {+ BKWidgetDraw w = BuiWidget(BK_WIDGET_ARROW, bb, BuiState(hovered, held));+ w.value = dir == ImGuiDir_Down ? 1.0f : dir == ImGuiDir_Left ? 2.0f : dir == ImGuiDir_Up ? 3.0f : 0.0f;+ BuiEmit(w);+ }+ else+ {+ RenderFrame(bb.Min, bb.Max, bg_col, true, g.Style.FrameRounding);+ RenderArrow(window->DrawList, bb.Min + ImVec2(ImMax(0.0f, (size.x - g.FontSize) * 0.5f), ImMax(0.0f, (size.y - g.FontSize) * 0.5f)), text_col, dir);+ } // BUI++ IMGUI_TEST_ENGINE_ITEM_INFO(id, str_id, g.LastItemData.StatusFlags);+ return pressed;+}++bool ImGui::ArrowButton(const char* str_id, ImGuiDir dir)+{+ float sz = GetFrameHeight();+ return ArrowButtonEx(str_id, dir, ImVec2(sz, sz), ImGuiButtonFlags_None);+}++// Button to close a window+bool ImGui::CloseButton(ImGuiID id, const ImVec2& pos)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ // Tweak 1: Shrink hit-testing area if button covers an abnormally large proportion of the visible region. That's in order to facilitate moving the window away. (#3825)+ // This may better be applied as a general hit-rect reduction mechanism for all widgets to ensure the area to move window is always accessible?+ const ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize));+ ImRect bb_interact = bb;+ const float area_to_visible_ratio = window->OuterRectClipped.GetArea() / bb.GetArea();+ if (area_to_visible_ratio < 1.5f)+ bb_interact.Expand(ImTrunc(bb_interact.GetSize() * -0.25f));++ // Tweak 2: We intentionally allow interaction when clipped so that a mechanical Alt,Right,Activate sequence can always close a window.+ // (this isn't the common behavior of buttons, but it doesn't affect the user because navigation tends to keep items visible in scrolling layer).+ bool is_clipped = !ItemAdd(bb_interact, id);++ bool hovered, held;+ bool pressed = ButtonBehavior(bb_interact, id, &hovered, &held);+ if (is_clipped)+ return pressed;++ // Render+ ImU32 bg_col = GetColorU32(held ? ImGuiCol_ButtonActive : ImGuiCol_ButtonHovered);+ if (hovered)+ window->DrawList->AddRectFilled(bb.Min, bb.Max, bg_col);+ RenderNavCursor(bb, id, ImGuiNavRenderCursorFlags_Compact);+ const ImU32 cross_col = GetColorU32(ImGuiCol_Text);+ const ImVec2 cross_center = bb.GetCenter();+ const float cross_extent = g.FontSize * 0.5f * 0.7071f - 1.0f;+ const float cross_thickness = 1.0f * (float)(int)g.Style._MainScale; // FIXME-DPI+ window->DrawList->AddLine(cross_center + ImVec2(+cross_extent, +cross_extent), cross_center + ImVec2(-cross_extent, -cross_extent), cross_col, cross_thickness);+ window->DrawList->AddLine(cross_center + ImVec2(+cross_extent, -cross_extent), cross_center + ImVec2(-cross_extent, +cross_extent), cross_col, cross_thickness);++ return pressed;+}++bool ImGui::CollapseButton(ImGuiID id, const ImVec2& pos)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize));+ bool is_clipped = !ItemAdd(bb, id);+ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_None);+ if (is_clipped)+ return pressed;++ // Render+ ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);+ ImU32 text_col = GetColorU32(ImGuiCol_Text);+ if (hovered || held)+ window->DrawList->AddRectFilled(bb.Min, bb.Max, bg_col);+ RenderNavCursor(bb, id, ImGuiNavRenderCursorFlags_Compact);+ RenderArrow(window->DrawList, bb.Min, text_col, window->Collapsed ? ImGuiDir_Right : ImGuiDir_Down, 1.0f);++ // Switch to moving the window after mouse is moved beyond the initial drag threshold+ if (IsItemActive() && IsMouseDragging(0))+ StartMouseMovingWindow(window);++ return pressed;+}++ImGuiID ImGui::GetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis)+{+ return window->GetID(axis == ImGuiAxis_X ? "#SCROLLX" : "#SCROLLY");+}++// Return scrollbar rectangle, must only be called for corresponding axis if window->ScrollbarX/Y is set.+ImRect ImGui::GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis)+{+ ImGuiContext& g = *GImGui;+ const ImRect outer_rect = window->Rect();+ const ImRect inner_rect = window->InnerRect;+ const float scrollbar_size = window->ScrollbarSizes[axis ^ 1]; // (ScrollbarSizes.x = width of Y scrollbar; ScrollbarSizes.y = height of X scrollbar)+ IM_ASSERT(scrollbar_size >= 0.0f);+ const float border_size = IM_ROUND(window->WindowBorderSize * 0.5f);+ const float border_top = (window->Flags & ImGuiWindowFlags_MenuBar) ? IM_ROUND(g.Style.FrameBorderSize * 0.5f) : (window->Flags & ImGuiWindowFlags_NoTitleBar) ? border_size : 0;+ if (axis == ImGuiAxis_X)+ return ImRect(inner_rect.Min.x + border_size, ImMax(outer_rect.Min.y + border_size, outer_rect.Max.y - border_size - scrollbar_size), inner_rect.Max.x - border_size, outer_rect.Max.y - border_size);+ else+ return ImRect(ImMax(outer_rect.Min.x, outer_rect.Max.x - border_size - scrollbar_size), inner_rect.Min.y + border_top, outer_rect.Max.x - border_size, inner_rect.Max.y - border_size);+}++void ImGui::ExtendHitBoxWhenNearViewportEdge(ImGuiWindow* window, ImRect* bb, float threshold, ImGuiAxis axis)+{+ ImRect window_rect = window->RootWindow->Rect();+ ImRect viewport_rect = window->Viewport->GetMainRect();+ if (window_rect.Min[axis] == viewport_rect.Min[axis] && bb->Min[axis] > window_rect.Min[axis] && bb->Min[axis] - threshold <= window_rect.Min[axis])+ bb->Min[axis] = window_rect.Min[axis];+ if (window_rect.Max[axis] == viewport_rect.Max[axis] && bb->Max[axis] < window_rect.Max[axis] && bb->Max[axis] + threshold >= window_rect.Max[axis])+ bb->Max[axis] = window_rect.Max[axis];+}++void ImGui::Scrollbar(ImGuiAxis axis)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ const ImGuiID id = GetWindowScrollbarID(window, axis);++ // Calculate scrollbar bounding box+ ImRect bb = GetWindowScrollbarRect(window, axis);+ ImDrawFlags rounding_corners = CalcRoundingFlagsForRectInRect(bb, window->Rect(), g.Style.WindowBorderSize);+ float size_visible = window->InnerRect.Max[axis] - window->InnerRect.Min[axis];+ float size_contents = window->ContentSize[axis] + window->WindowPadding[axis] * 2.0f;+ ImS64 scroll = (ImS64)window->Scroll[axis];+ ScrollbarEx(bb, id, axis, &scroll, (ImS64)size_visible, (ImS64)size_contents, rounding_corners);+ window->Scroll[axis] = (float)scroll;+}++// Vertical/Horizontal scrollbar+// The entire piece of code below is rather confusing because:+// - We handle absolute seeking (when first clicking outside the grab) and relative manipulation (afterward or when clicking inside the grab)+// - We store values as normalized ratio and in a form that allows the window content to change while we are holding on a scrollbar+// - We handle both horizontal and vertical scrollbars, which makes the terminology not ideal.+// Still, the code should probably be made simpler..+bool ImGui::ScrollbarEx(const ImRect& bb_frame, ImGuiID id, ImGuiAxis axis, ImS64* p_scroll_v, ImS64 size_visible_v, ImS64 size_contents_v, ImDrawFlags draw_rounding_flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return false;++ const float bb_frame_width = bb_frame.GetWidth();+ const float bb_frame_height = bb_frame.GetHeight();+ if (bb_frame_width <= 0.0f || bb_frame_height <= 0.0f)+ return false;++ // When we are too small, start hiding and disabling the grab (this reduce visual noise on very small window and facilitate using the window resize grab)+ float alpha = 1.0f;+ if ((axis == ImGuiAxis_Y) && bb_frame_height < bb_frame_width)+ alpha = ImSaturate(bb_frame_height / ImMax(bb_frame_width * 2.0f, 1.0f));+ if (alpha <= 0.0f)+ return false;++ const ImGuiStyle& style = g.Style;+ const bool allow_interaction = (alpha >= 1.0f);++ ImRect bb = bb_frame;+ float padding = IM_TRUNC(ImMin(style.ScrollbarPadding, ImMin(bb_frame_width, bb_frame_height) * 0.5f));+ bb.Expand(-padding);++ // V denote the main, longer axis of the scrollbar (= height for a vertical scrollbar)+ const float scrollbar_size_v = (axis == ImGuiAxis_X) ? bb.GetWidth() : bb.GetHeight();+ if (scrollbar_size_v < 1.0f)+ return false;++ // Calculate the height of our grabbable box. It generally represent the amount visible (vs the total scrollable amount)+ // But we maintain a minimum size in pixel to allow for the user to still aim inside.+ IM_ASSERT(ImMax(size_contents_v, size_visible_v) > 0.0f); // Adding this assert to check if the ImMax(XXX,1.0f) is still needed. PLEASE CONTACT ME if this triggers.+ const ImS64 win_size_v = ImMax(ImMax(size_contents_v, size_visible_v), (ImS64)1);+ const float grab_h_minsize = ImMin(bb.GetSize()[axis], style.GrabMinSize);+ const float grab_h_pixels = (float)(int)ImClamp(scrollbar_size_v * ((float)size_visible_v / (float)win_size_v), grab_h_minsize, scrollbar_size_v);+ const float grab_h_norm = grab_h_pixels / scrollbar_size_v;++ // As a special thing, we allow scrollbar near the edge of a screen/viewport to be reachable with mouse at the extreme edge (#9276)+ ImRect bb_hit = bb_frame;+ ExtendHitBoxWhenNearViewportEdge(window, &bb_hit, g.Style.WindowBorderSize, (ImGuiAxis)(axis ^ 1));++ // Handle input right away. None of the code of Begin() is relying on scrolling position before calling Scrollbar().+ bool held = false;+ bool hovered = false;+ ItemAdd(bb_frame, id, NULL, ImGuiItemFlags_NoNav);+ ButtonBehavior(bb_hit, id, &hovered, &held, ImGuiButtonFlags_NoNavFocus);++ const ImS64 scroll_max = ImMax((ImS64)1, size_contents_v - size_visible_v);+ float scroll_ratio = ImSaturate((float)*p_scroll_v / (float)scroll_max);+ float grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v; // Grab position in normalized space+ if (held && allow_interaction && grab_h_norm < 1.0f)+ {+ const float scrollbar_pos_v = bb.Min[axis];+ const float mouse_pos_v = g.IO.MousePos[axis];++ // Click position in scrollbar normalized space (0.0f->1.0f)+ const float clicked_v_norm = ImSaturate((mouse_pos_v - scrollbar_pos_v) / scrollbar_size_v);++ const int held_dir = (clicked_v_norm < grab_v_norm) ? -1 : (clicked_v_norm > grab_v_norm + grab_h_norm) ? +1 : 0;+ if (g.ActiveIdIsJustActivated)+ {+ // On initial click when held_dir == 0 (clicked over grab): calculate the distance between mouse and the center of the grab+ const bool scroll_to_clicked_location = (g.IO.ConfigScrollbarScrollByPage == false || g.IO.KeyShift || held_dir == 0);+ g.ScrollbarSeekMode = scroll_to_clicked_location ? 0 : (short)held_dir;+ g.ScrollbarClickDeltaToGrabCenter = (held_dir == 0 && !g.IO.KeyShift) ? clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f : 0.0f;+ }++ // Apply scroll (p_scroll_v will generally point on one member of window->Scroll)+ // It is ok to modify Scroll here because we are being called in Begin() after the calculation of ContentSize and before setting up our starting position+ if (g.ScrollbarSeekMode == 0)+ {+ // Absolute seeking+ const float scroll_v_norm = ImSaturate((clicked_v_norm - g.ScrollbarClickDeltaToGrabCenter - grab_h_norm * 0.5f) / (1.0f - grab_h_norm));+ *p_scroll_v = (ImS64)(scroll_v_norm * scroll_max);+ }+ else+ {+ // Page by page+ if (IsMouseClicked(ImGuiMouseButton_Left, ImGuiInputFlags_Repeat) && held_dir == g.ScrollbarSeekMode)+ {+ float page_dir = (g.ScrollbarSeekMode > 0.0f) ? +1.0f : -1.0f;+ *p_scroll_v = ImClamp(*p_scroll_v + (ImS64)(page_dir * size_visible_v), (ImS64)0, scroll_max);+ }+ }++ // Update values for rendering+ scroll_ratio = ImSaturate((float)*p_scroll_v / (float)scroll_max);+ grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v;++ // Update distance to grab now that we have seek'ed and saturated+ //if (seek_absolute)+ // g.ScrollbarClickDeltaToGrabCenter = clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f;+ }++ // Render+ const ImU32 bg_col = GetColorU32(ImGuiCol_ScrollbarBg);+ const ImU32 grab_col = GetColorU32(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab, alpha);+ window->DrawList->AddRectFilled(bb_frame.Min, bb_frame.Max, bg_col, window->WindowRounding, draw_rounding_flags);+ ImRect grab_rect;+ if (axis == ImGuiAxis_X)+ grab_rect = ImRect(ImLerp(bb.Min.x, bb.Max.x, grab_v_norm), bb.Min.y, ImLerp(bb.Min.x, bb.Max.x, grab_v_norm) + grab_h_pixels, bb.Max.y);+ else+ grab_rect = ImRect(bb.Min.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm), bb.Max.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm) + grab_h_pixels);+ window->DrawList->AddRectFilled(grab_rect.Min, grab_rect.Max, grab_col, style.ScrollbarRounding);++ return held;+}++// - Read about ImTextureID/ImTextureRef here: https://github.com/ocornut/imgui/wiki/Image-Loading-and-Displaying-Examples+// - 'uv0' and 'uv1' are texture coordinates. Read about them from the same link above.+void ImGui::ImageWithBg(ImTextureRef tex_ref, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& bg_col, const ImVec4& tint_col)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ const ImVec2 padding(g.Style.ImageBorderSize, g.Style.ImageBorderSize);+ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + image_size + padding * 2.0f);+ ItemSize(bb);+ if (!ItemAdd(bb, 0))+ return;++ // Render+ float rounding = g.Style.ImageRounding;+ if (bg_col.w > 0.0f)+ window->DrawList->AddRectFilled(bb.Min + padding, bb.Max - padding, GetColorU32(bg_col), rounding);+ if (rounding > 0.0f)+ window->DrawList->AddImageRounded(tex_ref, bb.Min + padding, bb.Max - padding, uv0, uv1, GetColorU32(tint_col), rounding);+ else+ window->DrawList->AddImage(tex_ref, bb.Min + padding, bb.Max - padding, uv0, uv1, GetColorU32(tint_col));+ if (g.Style.ImageBorderSize > 0.0f)+ window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(ImGuiCol_Border), rounding, g.Style.ImageBorderSize);+}++void ImGui::Image(ImTextureRef tex_ref, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1)+{+ ImageWithBg(tex_ref, image_size, uv0, uv1);+}++// 1.91.9 (February 2025) removed 'tint_col' and 'border_col' parameters, made border size not depend on color value. (#8131, #8238)+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS+void ImGui::Image(ImTextureRef tex_ref, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& tint_col, const ImVec4& border_col)+{+ ImGuiContext& g = *GImGui;+ PushStyleVar(ImGuiStyleVar_ImageBorderSize, (border_col.w > 0.0f) ? ImMax(1.0f, g.Style.ImageBorderSize) : 0.0f); // Preserve legacy behavior where border is always visible when border_col's Alpha is >0.0f+ PushStyleColor(ImGuiCol_Border, border_col);+ ImageWithBg(tex_ref, image_size, uv0, uv1, ImVec4(0, 0, 0, 0), tint_col);+ PopStyleColor();+ PopStyleVar();+}+#endif++bool ImGui::ImageButtonEx(ImGuiID id, ImTextureRef tex_ref, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& bg_col, const ImVec4& tint_col, ImGuiButtonFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ const ImVec2 padding = g.Style.FramePadding;+ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + image_size + padding * 2.0f);+ ItemSize(bb);+ if (!ItemAdd(bb, id))+ return false;++ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);++ // Render+ const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);+ RenderNavCursor(bb, id);+ RenderFrame(bb.Min, bb.Max, col, true, g.Style.FrameRounding);+ if (bg_col.w > 0.0f)+ window->DrawList->AddRectFilled(bb.Min + padding, bb.Max - padding, GetColorU32(bg_col));+ float image_rounding = ImMax(g.Style.FrameRounding - ImMax(padding.x, padding.y), g.Style.ImageRounding);+ if (image_rounding > 0.0f)+ window->DrawList->AddImageRounded(tex_ref, bb.Min + padding, bb.Max - padding, uv0, uv1, GetColorU32(tint_col), image_rounding);+ else+ window->DrawList->AddImage(tex_ref, bb.Min + padding, bb.Max - padding, uv0, uv1, GetColorU32(tint_col));++ return pressed;+}++// - ImageButton() adds style.FramePadding*2.0f to provided size. This is in order to facilitate fitting an image in a button.+// - ImageButton() draws a background based on regular Button() color + optionally an inner background if specified. (#8165) // FIXME: Maybe that's not the best design?+bool ImGui::ImageButton(const char* str_id, ImTextureRef tex_ref, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& bg_col, const ImVec4& tint_col)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return false;++ return ImageButtonEx(window->GetID(str_id), tex_ref, image_size, uv0, uv1, bg_col, tint_col);+}++#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS+// Legacy API obsoleted in 1.89. Two differences with new ImageButton()+// - old ImageButton() used ImTextureID as item id (created issue with multiple buttons with same image, transient texture id values, opaque computation of ID)+// - new ImageButton() requires an explicit 'const char* str_id'+// - old ImageButton() had frame_padding' override argument.+// - new ImageButton() always use style.FramePadding.+/*+bool ImGui::ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, int frame_padding, const ImVec4& bg_col, const ImVec4& tint_col)+{+ // Default to using texture ID as ID. User can still push string/integer prefixes.+ PushID((ImTextureID)(intptr_t)user_texture_id);+ if (frame_padding >= 0)+ PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2((float)frame_padding, (float)frame_padding));+ bool ret = ImageButton("", user_texture_id, size, uv0, uv1, bg_col, tint_col);+ if (frame_padding >= 0)+ PopStyleVar();+ PopID();+ return ret;+}+*/+#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS++bool ImGui::Checkbox(const char* label, bool* v)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);+ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);++ const float square_sz = GetFrameHeight();+ const ImVec2 pos = window->DC.CursorPos;+ const ImRect total_bb(pos, pos + ImVec2(square_sz + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), label_size.y + style.FramePadding.y * 2.0f));+ ItemSize(total_bb, style.FramePadding.y);+ const bool is_visible = ItemAdd(total_bb, id);+ const bool is_multi_select = (g.LastItemData.ItemFlags & ImGuiItemFlags_IsMultiSelect) != 0;+ if (!is_visible)+ if (!is_multi_select || !g.BoxSelectState.UnclipMode || !g.BoxSelectState.UnclipRect.Overlaps(total_bb)) // Extra layer of "no logic clip" for box-select support+ {+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));+ return false;+ }++ // Range-Selection/Multi-selection support (header)+ bool checked = *v;+ if (is_multi_select)+ MultiSelectItemHeader(id, &checked, NULL);++ bool hovered, held;+ // BUI: Blender toggles on press (ui_do_but_TOG) and drag-toggles: dragging over other+ // checkboxes with the button held sets them to the pressed one's new state.+ const bool bui_blender = BuiOn() && !is_multi_select;+ bool pressed = ButtonBehavior(total_bb, id, &hovered, &held, bui_blender ? ImGuiButtonFlags_PressedOnClick : ImGuiButtonFlags_None);++ // Range-Selection/Multi-selection support (footer)+ if (is_multi_select)+ MultiSelectItemFooter(id, &checked, &pressed, ImGuiMultiSelectFlags_CheckboxMode_);+ else if (pressed)+ checked = !checked;+ if (bui_blender) // BUI: drag-toggle+ BuiDragToggle(id, total_bb, pressed, &checked);++ if (*v != checked)+ {+ *v = checked;+ pressed = true; // return value+ MarkItemEdited(id);+ }++ const ImRect check_bb(pos, pos + ImVec2(square_sz, square_sz));+ const bool mixed_value = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;+ if (is_visible && BuiOn()) // BUI: Blender checkbox (checkbox_draw: wcol_option, box + label)+ {+ RenderNavCursor(total_bb, id);+ int st = hovered ? BK_WS_HOVER : 0;+ if (mixed_value)+ st |= BK_WS_MIXED;+ else if (*v)+ st |= BK_WS_SELECTED;+ const bool text = BuiTextOk();+ BuiEmit(BuiWidget(BK_WIDGET_CHECKBOX, ImRect(pos, ImVec2(ImMax(total_bb.Max.x, check_bb.Max.x + label_size.x + style.ItemInnerSpacing.x), pos.y + square_sz)), st), text ? label : NULL, label_end);+ if (g.LogEnabled)+ LogRenderedText(&pos, mixed_value ? "[~]" : *v ? "[x]" : "[ ]");+ if (!text && label_size.x > 0.0f)+ RenderText(ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y), label, label_end, false);+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));+ return pressed;+ }+ if (is_visible)+ {+ RenderNavCursor(total_bb, id);+ ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : (mixed_value || checked) ? ImGuiCol_CheckboxSelectedBg : ImGuiCol_FrameBg);+ ImU32 check_col = GetColorU32(ImGuiCol_CheckMark);+ RenderFrame(check_bb.Min, check_bb.Max, bg_col, true, style.FrameRounding);+ if (mixed_value)+ {+ // Undocumented tristate/mixed/indeterminate checkbox (#2644)+ // This may seem awkwardly designed because the aim is to make ImGuiItemFlags_MixedValue supported by all widgets (not just checkbox)+ ImVec2 pad(ImMax(1.0f, IM_TRUNC(square_sz / 3.6f)), ImMax(1.0f, IM_TRUNC(square_sz / 3.6f)));+ window->DrawList->AddRectFilled(check_bb.Min + pad, check_bb.Max - pad, check_col, style.FrameRounding);+ }+ else if (*v)+ {+ const float pad = ImMax(1.0f, IM_TRUNC(square_sz / 6.0f));+ RenderCheckMark(window->DrawList, check_bb.Min + ImVec2(pad, pad), check_col, square_sz - pad * 2.0f);+ }+ }+ const ImVec2 label_pos = ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y);+ if (g.LogEnabled)+ LogRenderedText(&label_pos, mixed_value ? "[~]" : *v ? "[x]" : "[ ]");+ if (is_visible && label_size.x > 0.0f)+ RenderText(label_pos, label, label_end, false);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));+ return pressed;+}++template<typename T>+bool ImGui::CheckboxFlagsT(const char* label, T* flags, T flags_value)+{+ bool all_on = (*flags & flags_value) == flags_value;+ bool any_on = (*flags & flags_value) != 0;+ bool pressed;+ if (!all_on && any_on)+ {+ ImGuiContext& g = *GImGui;+ g.NextItemData.ItemFlagsSet |= ImGuiItemFlags_MixedValue;+ pressed = Checkbox(label, &all_on);+ }+ else+ {+ pressed = Checkbox(label, &all_on);++ }+ if (pressed)+ {+ if (all_on)+ *flags |= flags_value;+ else+ *flags &= ~flags_value;+ }+ return pressed;+}++bool ImGui::CheckboxFlags(const char* label, int* flags, int flags_value)+{+ return CheckboxFlagsT(label, flags, flags_value);+}++bool ImGui::CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value)+{+ return CheckboxFlagsT(label, flags, flags_value);+}++bool ImGui::CheckboxFlags(const char* label, ImS64* flags, ImS64 flags_value)+{+ return CheckboxFlagsT(label, flags, flags_value);+}++bool ImGui::CheckboxFlags(const char* label, ImU64* flags, ImU64 flags_value)+{+ return CheckboxFlagsT(label, flags, flags_value);+}++bool ImGui::RadioButton(const char* label, bool active)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);+ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);++ const float square_sz = GetFrameHeight();+ const ImVec2 pos = window->DC.CursorPos;+ const ImRect check_bb(pos, pos + ImVec2(square_sz, square_sz));+ const ImRect total_bb(pos, pos + ImVec2(square_sz + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), label_size.y + style.FramePadding.y * 2.0f));+ ItemSize(total_bb, style.FramePadding.y);+ if (!ItemAdd(total_bb, id))+ return false;++ ImVec2 center = check_bb.GetCenter();+ center.x = IM_ROUND(center.x);+ center.y = IM_ROUND(center.y);+ const float radius = (square_sz - 1.0f) * 0.5f;++ bool hovered, held;+ bool pressed = ButtonBehavior(total_bb, id, &hovered, &held);+ if (pressed)+ MarkItemEdited(id);++ RenderNavCursor(total_bb, id);+ if (BuiOn()) // BUI: Blender option widget, round, with a dot when chosen+ {+ int st = hovered ? BK_WS_HOVER : 0;+ if (active && (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) == 0)+ st |= BK_WS_SELECTED;+ const bool text = BuiTextOk();+ BuiEmit(BuiWidget(BK_WIDGET_RADIO, ImRect(pos, ImVec2(ImMax(total_bb.Max.x, check_bb.Max.x + label_size.x + style.ItemInnerSpacing.x), pos.y + square_sz)), st), text ? label : NULL, label_end);+ if (g.LogEnabled)+ LogRenderedText(&pos, active ? "(x)" : "( )");+ if (!text && label_size.x > 0.0f)+ RenderText(ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y), label, label_end, false);+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return pressed;+ }+ const int num_segment = window->DrawList->_CalcCircleAutoSegmentCount(radius);+ window->DrawList->AddCircleFilled(center, radius, GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg), num_segment);+ if (active && (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) == 0)+ {+ const float pad = ImMax(1.0f, IM_TRUNC(square_sz / 6.0f));+ window->DrawList->AddCircleFilled(center, radius - pad, GetColorU32(ImGuiCol_CheckMark));+ }++ if (style.FrameBorderSize > 0.0f)+ {+ window->DrawList->AddCircle(center + ImVec2(1, 1), radius, GetColorU32(ImGuiCol_BorderShadow), num_segment, style.FrameBorderSize);+ window->DrawList->AddCircle(center, radius, GetColorU32(ImGuiCol_Border), num_segment, style.FrameBorderSize);+ }++ ImVec2 label_pos = ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y);+ if (g.LogEnabled)+ LogRenderedText(&label_pos, active ? "(x)" : "( )");+ if (label_size.x > 0.0f)+ RenderText(label_pos, label, label_end, false);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return pressed;+}++// FIXME: This would work nicely if it was a public template, e.g. 'template<T> RadioButton(const char* label, T* v, T v_button)', but I'm not sure how we would expose it..+bool ImGui::RadioButton(const char* label, int* v, int v_button)+{+ const bool pressed = RadioButton(label, *v == v_button);+ if (pressed)+ *v = v_button;+ return pressed;+}++// size_arg (for each axis) < 0.0f: align to end, 0.0f: auto, > 0.0f: specified size+void ImGui::ProgressBar(float fraction, const ImVec2& size_arg, const char* overlay)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;++ ImVec2 pos = window->DC.CursorPos;+ ImVec2 size = CalcItemSize(size_arg, CalcItemWidth(), g.FontSize + style.FramePadding.y * 2.0f);+ ImRect bb(pos, pos + size);+ ItemSize(size, style.FramePadding.y);+ if (!ItemAdd(bb, 0))+ return;++ // Fraction < 0.0f will display an indeterminate progress bar animation+ // The value must be animated along with time, so e.g. passing '-1.0f * ImGui::GetTime()' as fraction works.+ const bool is_indeterminate = (fraction < 0.0f);+ if (!is_indeterminate)+ fraction = ImSaturate(fraction);++ // Out of courtesy we accept a NaN fraction without crashing+ float fill_n0 = 0.0f;+ float fill_n1 = (fraction == fraction) ? fraction : 0.0f;++ if (is_indeterminate)+ {+ const float fill_width_n = 0.2f;+ fill_n0 = ImFmod(-fraction, 1.0f) * (1.0f + fill_width_n) - fill_width_n;+ fill_n1 = ImSaturate(fill_n0 + fill_width_n);+ fill_n0 = ImSaturate(fill_n0);+ }++ // Render+ if (BuiOn()) // BUI: Blender progress bar (progress_draw: wcol_progress, text centered)+ {+ char buf[32];+ const char* text = overlay;+ if (!text && !is_indeterminate)+ {+ ImFormatString(buf, IM_COUNTOF(buf), "%.0f%%", fraction * 100 + 0.01f);+ text = buf;+ }+ BKWidgetDraw w = BuiWidget(BK_WIDGET_PROGRESS, bb, 0);+ w.value = fill_n1; // indeterminate: the moving end of ImGui's animated segment+ BuiEmit(w, BuiTextOk() ? text : NULL);+ if (text && !BuiTextOk())+ RenderTextClipped(bb.Min, bb.Max, text, NULL, NULL, ImVec2(0.5f, 0.5f), &bb);+ return;+ }+ RenderFrame(bb.Min, bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);+ bb.Expand(ImVec2(-style.FrameBorderSize, -style.FrameBorderSize));+ float fill_x0 = ImLerp(bb.Min.x, bb.Max.x, fill_n0);+ float fill_x1 = ImLerp(bb.Min.x, bb.Max.x, fill_n1);+ if (fill_x0 < fill_x1)+ RenderRectFilledInRangeH(window->DrawList, bb, GetColorU32(ImGuiCol_PlotHistogram), fill_x0, fill_x1, style.FrameRounding);++ // Default displaying the fraction as percentage string, but user can override it+ // Don't display text for indeterminate bars by default+ char overlay_buf[32];+ if (!is_indeterminate || overlay != NULL)+ {+ if (!overlay)+ {+ ImFormatString(overlay_buf, IM_COUNTOF(overlay_buf), "%.0f%%", fraction * 100 + 0.01f);+ overlay = overlay_buf;+ }++ ImVec2 overlay_size = CalcTextSize(overlay, NULL);+ if (overlay_size.x > 0.0f)+ {+ float text_x = is_indeterminate ? (bb.Min.x + bb.Max.x - overlay_size.x) * 0.5f : fill_x1 + style.ItemSpacing.x;+ RenderTextClipped(ImVec2(ImClamp(text_x, bb.Min.x, bb.Max.x - overlay_size.x - style.ItemInnerSpacing.x), bb.Min.y), bb.Max, overlay, NULL, &overlay_size, ImVec2(0.0f, 0.5f), &bb);+ }+ }+}++void ImGui::Bullet()+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const float line_height = ImMax(ImMin(window->DC.CurrLineSize.y, g.FontSize + style.FramePadding.y * 2), g.FontSize);+ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(g.FontSize, line_height));+ ItemSize(bb);+ if (!ItemAdd(bb, 0))+ {+ SameLine(0, style.FramePadding.x * 2);+ return;+ }++ // Render and stay on same line+ ImU32 text_col = GetColorU32(ImGuiCol_Text);+ RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, line_height * 0.5f), text_col);+ SameLine(0, style.FramePadding.x * 2.0f);+}++// This is provided as a convenience for being an often requested feature.+// FIXME-STYLE: we delayed adding as there is a larger plan to revamp the styling system.+// Because of this we currently don't provide many styling options for this widget+// (e.g. hovered/active colors are automatically inferred from a single color).+bool ImGui::TextLink(const char* label)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiID id = window->GetID(label);+ const char* label_end = FindRenderedTextEnd(label);++ ImVec2 pos(window->DC.CursorPos.x, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);+ ImVec2 size = CalcTextSize(label, label_end, false);+ ImRect bb(pos, pos + size);+ ItemSize(size, 0.0f);+ if (!ItemAdd(bb, id))+ return false;++ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held);+ RenderNavCursor(bb, id);++ if (hovered)+ SetMouseCursor(ImGuiMouseCursor_Hand);++ ImVec4 text_colf = g.Style.Colors[ImGuiCol_TextLink];+ ImVec4 line_colf = text_colf;+ {+ // FIXME-STYLE: Read comments above. This widget is NOT written in the same style as some earlier widgets,+ // as we are currently experimenting/planning a different styling system.+ float h, s, v;+ ColorConvertRGBtoHSV(text_colf.x, text_colf.y, text_colf.z, h, s, v);+ if (held || hovered)+ {+ v = ImSaturate(v + (held ? 0.4f : 0.3f));+ h = ImFmod(h + 0.02f, 1.0f);+ }+ ColorConvertHSVtoRGB(h, s, v, text_colf.x, text_colf.y, text_colf.z);+ v = ImSaturate(v - 0.20f);+ ColorConvertHSVtoRGB(h, s, v, line_colf.x, line_colf.y, line_colf.z);+ }++ float line_y = bb.Max.y + ImFloor(g.FontBaked->Descent * g.FontBakedScale * 0.20f);+ window->DrawList->AddLineH(bb.Min.x, bb.Max.x, line_y, GetColorU32(line_colf), 1.0f * (float)(int)g.Style._MainScale); // FIXME-TEXT: Underline mode // FIXME-DPI++ PushStyleColor(ImGuiCol_Text, GetColorU32(text_colf));+ RenderText(bb.Min, label, label_end, false);+ PopStyleColor();++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return pressed;+}++bool ImGui::TextLinkOpenURL(const char* label, const char* url)+{+ ImGuiContext& g = *GImGui;+ if (url == NULL)+ url = label;+ bool pressed = TextLink(label);+ if (pressed && g.PlatformIO.Platform_OpenInShellFn != NULL)+ g.PlatformIO.Platform_OpenInShellFn(&g, url);+ SetItemTooltip(LocalizeGetMsg(ImGuiLocKey_OpenLink_s), url); // It is more reassuring for user to _always_ display URL when it is the same as the label.+ if (BeginPopupContextItem())+ {+ if (MenuItem(LocalizeGetMsg(ImGuiLocKey_CopyLink)))+ SetClipboardText(url);+ EndPopup();+ }+ return pressed;+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: Low-level Layout helpers+//-------------------------------------------------------------------------+// - Spacing()+// - Dummy()+// - NewLine()+// - AlignTextToFramePadding()+// - SeparatorEx() [Internal]+// - Separator()+// - SplitterBehavior() [Internal]+// - ShrinkWidths() [Internal]+//-------------------------------------------------------------------------++void ImGui::Spacing()+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;+ ItemSize(ImVec2(0, 0));+}++void ImGui::Dummy(const ImVec2& size)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);+ ItemSize(size);+ ItemAdd(bb, 0);+}++void ImGui::NewLine()+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ ImGuiContext& g = *GImGui;+ const ImGuiLayoutType backup_layout_type = window->DC.LayoutType;+ window->DC.LayoutType = ImGuiLayoutType_Vertical;+ window->DC.IsSameLine = false;+ if (window->DC.CurrLineSize.y > 0.0f) // In the event that we are on a line with items that is smaller that FontSize high, we will preserve its height.+ ItemSize(ImVec2(0, 0));+ else+ ItemSize(ImVec2(0.0f, g.FontSize));+ window->DC.LayoutType = backup_layout_type;+}++void ImGui::AlignTextToFramePadding()+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ ImGuiContext& g = *GImGui;+ window->DC.CurrLineSize.y = ImMax(window->DC.CurrLineSize.y, g.FontSize + g.Style.FramePadding.y * 2);+ window->DC.CurrLineTextBaseOffset = ImMax(window->DC.CurrLineTextBaseOffset, g.Style.FramePadding.y);+}++// Horizontal/vertical separating line+// FIXME: Surprisingly, this seemingly trivial widget is a victim of many different legacy/tricky layout issues.+// Note how thickness == 1.0f is handled specifically as not moving CursorPos by 'thickness', but other values are.+void ImGui::SeparatorEx(ImGuiSeparatorFlags flags, float thickness)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ ImGuiContext& g = *GImGui;+ IM_ASSERT(ImIsPowerOfTwo(flags & (ImGuiSeparatorFlags_Horizontal | ImGuiSeparatorFlags_Vertical))); // Check that only 1 option is selected+ IM_ASSERT(thickness > 0.0f);++ if (flags & ImGuiSeparatorFlags_Vertical)+ {+ // Vertical separator, for menu bars (use current line height).+ float y1 = window->DC.CursorPos.y;+ float y2 = window->DC.CursorPos.y + window->DC.CurrLineSize.y;+ const ImRect bb(ImVec2(window->DC.CursorPos.x, y1), ImVec2(window->DC.CursorPos.x + thickness, y2));+ ItemSize(ImVec2(thickness, 0.0f));+ if (!ItemAdd(bb, 0))+ return;++ // Draw+ window->DrawList->AddRectFilled(bb.Min, bb.Max, GetColorU32(ImGuiCol_Separator));+ if (g.LogEnabled)+ LogText(" |");+ }+ else if (flags & ImGuiSeparatorFlags_Horizontal)+ {+ // Horizontal Separator+ float x1 = window->DC.CursorPos.x;+ float x2 = window->WorkRect.Max.x;++ // Preserve legacy behavior inside Columns()+ // Before Tables API happened, we relied on Separator() to span all columns of a Columns() set.+ // We currently don't need to provide the same feature for tables because tables naturally have border features.+ ImGuiOldColumns* columns = (flags & ImGuiSeparatorFlags_SpanAllColumns) ? window->DC.CurrentColumns : NULL;+ if (columns)+ {+ x1 = window->Pos.x + window->DC.Indent.x; // Used to be Pos.x before 2023/10/03+ x2 = window->Pos.x + window->Size.x;+ PushColumnsBackground();+ }++ // We don't provide our width to the layout so that it doesn't get feed back into AutoFit+ // FIXME: This prevents ->CursorMaxPos based bounding box evaluation from working (e.g. TableEndCell)++ // Between 1.71 and 1.92.7, we maintained a hack where a 1.0f thin Separator() would not impact layout.+ // This was mostly chosen to allow backward compatibility with user's code assuming zero-height when calculating height for layout (e.g. bottom alignment of a status bar).+ // In order to handle scaling we need to scale separator thickness and it would not makes sense to have a disparity depending on height.+ ////float thickness_for_layout = (thickness == 1.0f) ? 0.0f : thickness; // FIXME: See 1.70/1.71 Separator() change: makes legacy 1-px separator not affect layout yet. Should change.+ const ImRect bb(ImVec2(x1, window->DC.CursorPos.y), ImVec2(x2, window->DC.CursorPos.y + thickness));+ ItemSize(ImVec2(0.0f, thickness));++ if (ItemAdd(bb, 0))+ {+ // Draw+ window->DrawList->AddRectFilled(bb.Min, bb.Max, GetColorU32(ImGuiCol_Separator));+ if (g.LogEnabled)+ LogRenderedText(&bb.Min, "--------------------------------\n");++ }+ if (columns)+ {+ PopColumnsBackground();+ columns->LineMinY = window->DC.CursorPos.y;+ }+ }+}++void ImGui::Separator()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return;++ // Those flags should eventually be configurable by the user+ ImGuiSeparatorFlags flags = (window->DC.LayoutType == ImGuiLayoutType_Horizontal) ? ImGuiSeparatorFlags_Vertical : ImGuiSeparatorFlags_Horizontal;++ // Only applies to legacy Columns() api as they relied on Separator() a lot.+ if (window->DC.CurrentColumns)+ flags |= ImGuiSeparatorFlags_SpanAllColumns;++ SeparatorEx(flags, ImMax(g.Style.SeparatorSize, 1.0f));+}++void ImGui::SeparatorTextEx(ImGuiID id, const char* label, const char* label_end, float extra_w)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ ImGuiStyle& style = g.Style;++ const ImVec2 label_size = CalcTextSize(label, label_end, false);+ const ImVec2 pos = window->DC.CursorPos;+ const ImVec2 padding = style.SeparatorTextPadding;++ const float separator_thickness = style.SeparatorTextBorderSize;+ const ImVec2 min_size(label_size.x + extra_w + padding.x * 2.0f, ImMax(label_size.y + padding.y * 2.0f, separator_thickness));+ const ImRect bb(pos, ImVec2(window->WorkRect.Max.x, pos.y + min_size.y));+ const float text_baseline_y = ImTrunc((bb.GetHeight() - label_size.y) * style.SeparatorTextAlign.y + 0.999f); //ImMax(padding.y, ImTrunc((style.SeparatorTextSize - label_size.y) * 0.5f));+ ItemSize(min_size, text_baseline_y);+ if (!ItemAdd(bb, id))+ return;++ const float sep1_x1 = pos.x;+ const float sep2_x2 = bb.Max.x;+ float seps_y = ImTrunc((bb.Min.y + bb.Max.y) * 0.5f) + 1.0f;++ const float label_avail_w = ImMax(0.0f, sep2_x2 - sep1_x1 - padding.x * 2.0f);+ const ImVec2 label_pos(pos.x + padding.x + ImMax(0.0f, (label_avail_w - label_size.x - extra_w) * style.SeparatorTextAlign.x), pos.y + text_baseline_y); // FIXME-ALIGN++ // This allows using SameLine() to position something in the 'extra_w'+ window->DC.CursorPosPrevLine.x = label_pos.x + label_size.x;++ const ImU32 separator_col = GetColorU32(ImGuiCol_Separator);+ if (label_size.x > 0.0f)+ {+ const float sep1_x2 = label_pos.x - style.ItemSpacing.x;+ const float sep2_x1 = label_pos.x + label_size.x + extra_w + style.ItemSpacing.x;+ if (sep1_x2 > sep1_x1 && separator_thickness > 0.0f)+ window->DrawList->AddLineH(sep1_x1, sep1_x2, seps_y, separator_col, separator_thickness, ImDrawFlags_StrokeCenterBiased);+ if (sep2_x2 > sep2_x1 && separator_thickness > 0.0f)+ window->DrawList->AddLineH(sep2_x1, sep2_x2, seps_y, separator_col, separator_thickness, ImDrawFlags_StrokeCenterBiased);+ if (g.LogEnabled)+ LogSetNextTextDecoration("---", NULL);+ RenderTextEllipsis(window->DrawList, label_pos, ImVec2(bb.Max.x, bb.Max.y + style.ItemSpacing.y), bb.Max.x, label, label_end, &label_size);+ }+ else+ {+ if (g.LogEnabled)+ LogText("---");+ if (separator_thickness > 0.0f)+ window->DrawList->AddLineH(sep1_x1, sep2_x2, seps_y, separator_col, separator_thickness, ImDrawFlags_StrokeCenterBiased);+ }+}++void ImGui::SeparatorText(const char* label)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;++ // The SeparatorText() vs SeparatorTextEx() distinction is designed to be considerate that we may want:+ // - allow separator-text to be draggable items (would require a stable ID + a noticeable highlight)+ // - this high-level entry point to allow formatting? (which in turns may require ID separate from formatted string)+ // - because of this we probably can't turn 'const char* label' into 'const char* fmt, ...'+ // Otherwise, we can decide that users wanting to drag this would layout a dedicated drag-item,+ // and then we can turn this into a format function.+ SeparatorTextEx(0, label, FindRenderedTextEnd(label), 0.0f);+}++// Using 'hover_visibility_delay' allows us to hide the highlight and mouse cursor for a short time, which can be convenient to reduce visual noise.+bool ImGui::SplitterBehavior(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend, float hover_visibility_delay, ImU32 bg_col)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ if (!ItemAdd(bb, id, NULL, ImGuiItemFlags_NoNav))+ return false;++ // FIXME: AFAIK the only leftover reason for passing ImGuiButtonFlags_AllowOverlap here is+ // to allow caller of SplitterBehavior() to call SetItemAllowOverlap() after the item.+ // Nowadays we would instead want to use SetNextItemAllowOverlap() before the item.+ ImGuiButtonFlags button_flags = ImGuiButtonFlags_FlattenChildren;+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS+ button_flags |= ImGuiButtonFlags_AllowOverlap;+#endif++ bool hovered, held;+ ImRect bb_interact = bb;+ bb_interact.Expand(axis == ImGuiAxis_Y ? ImVec2(0.0f, hover_extend) : ImVec2(hover_extend, 0.0f));+ ButtonBehavior(bb_interact, id, &hovered, &held, button_flags);+ if (hovered)+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HoveredRect; // for IsItemHovered(), because bb_interact is larger than bb++ if (held || (hovered && g.HoveredIdPreviousFrame == id && g.HoveredIdTimer >= hover_visibility_delay))+ SetMouseCursor(axis == ImGuiAxis_Y ? ImGuiMouseCursor_ResizeNS : ImGuiMouseCursor_ResizeEW);++ ImRect bb_render = bb;+ if (held)+ {+ float mouse_delta = (g.IO.MousePos - g.ActiveIdClickOffset - bb_interact.Min)[axis];++ // Minimum pane size+ float size_1_maximum_delta = ImMax(0.0f, *size1 - min_size1);+ float size_2_maximum_delta = ImMax(0.0f, *size2 - min_size2);+ if (mouse_delta < -size_1_maximum_delta)+ mouse_delta = -size_1_maximum_delta;+ if (mouse_delta > size_2_maximum_delta)+ mouse_delta = size_2_maximum_delta;++ // Apply resize+ if (mouse_delta != 0.0f)+ {+ *size1 = ImMax(*size1 + mouse_delta, min_size1);+ *size2 = ImMax(*size2 - mouse_delta, min_size2);+ bb_render.Translate((axis == ImGuiAxis_X) ? ImVec2(mouse_delta, 0.0f) : ImVec2(0.0f, mouse_delta));+ MarkItemEdited(id);+ }+ }++ // Render at new position+ if (bg_col & IM_COL32_A_MASK)+ window->DrawList->AddRectFilled(bb_render.Min, bb_render.Max, bg_col, 0.0f);+ const ImU32 col = GetColorU32(held ? ImGuiCol_SeparatorActive : (hovered && g.HoveredIdTimer >= hover_visibility_delay) ? ImGuiCol_SeparatorHovered : ImGuiCol_Separator);+ window->DrawList->AddRectFilled(bb_render.Min, bb_render.Max, col, 0.0f);++ return held;+}++static int IMGUI_CDECL ShrinkWidthItemComparer(const void* lhs, const void* rhs)+{+ const ImGuiShrinkWidthItem* a = (const ImGuiShrinkWidthItem*)lhs;+ const ImGuiShrinkWidthItem* b = (const ImGuiShrinkWidthItem*)rhs;+ if (int d = (int)(b->Width - a->Width))+ return d;+ return b->Index - a->Index;+}++// Shrink excess width from a set of item, by removing width from the larger items first.+// Set items Width to -1.0f to disable shrinking this item.+void ImGui::ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess, float width_min)+{+ if (count == 1)+ {+ if (items[0].Width >= 0.0f)+ items[0].Width = ImMax(items[0].Width - width_excess, width_min);+ return;+ }+ ImQsort(items, (size_t)count, sizeof(ImGuiShrinkWidthItem), ShrinkWidthItemComparer); // Sort largest first, smallest last.+ int count_same_width = 1;+ while (width_excess > 0.001f && count_same_width < count)+ {+ while (count_same_width < count && items[0].Width <= items[count_same_width].Width)+ count_same_width++;+ float max_width_to_remove_per_item = (count_same_width < count && items[count_same_width].Width >= 0.0f) ? (items[0].Width - items[count_same_width].Width) : (items[0].Width - 1.0f);+ max_width_to_remove_per_item = ImMin(items[0].Width - width_min, max_width_to_remove_per_item);+ if (max_width_to_remove_per_item <= 0.0f)+ break;+ float base_width_to_remove_per_item = ImMin(width_excess / count_same_width, max_width_to_remove_per_item);+ for (int item_n = 0; item_n < count_same_width; item_n++)+ {+ float width_to_remove_for_this_item = ImMin(base_width_to_remove_per_item, items[item_n].Width - width_min);+ items[item_n].Width -= width_to_remove_for_this_item;+ width_excess -= width_to_remove_for_this_item;+ }+ }++ // Round width and redistribute remainder+ // Ensure that e.g. the right-most tab of a shrunk tab-bar always reaches exactly at the same distance from the right-most edge of the tab bar separator.+ width_excess = 0.0f;+ for (int n = 0; n < count; n++)+ {+ float width_rounded = ImTrunc(items[n].Width);+ width_excess += items[n].Width - width_rounded;+ items[n].Width = width_rounded;+ }+ while (width_excess > 0.0f)+ for (int n = 0; n < count && width_excess > 0.0f; n++)+ {+ float width_to_add = ImMin(items[n].InitialWidth - items[n].Width, 1.0f);+ items[n].Width += width_to_add;+ width_excess -= width_to_add;+ }+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: ComboBox+//-------------------------------------------------------------------------+// - CalcMaxPopupHeightFromItemCount() [Internal]+// - BeginCombo()+// - BeginComboPopup() [Internal]+// - EndCombo()+// - BeginComboPreview() [Internal]+// - EndComboPreview() [Internal]+// - Combo()+//-------------------------------------------------------------------------++static float CalcMaxPopupHeightFromItemCount(int items_count)+{+ ImGuiContext& g = *GImGui;+ if (items_count <= 0)+ return FLT_MAX;+ return (g.FontSize + g.Style.ItemSpacing.y) * items_count - g.Style.ItemSpacing.y + (g.Style.WindowPadding.y * 2);+}++bool ImGui::BeginCombo(const char* label, const char* preview_value, ImGuiComboFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();++ ImGuiNextWindowDataFlags backup_next_window_data_flags = g.NextWindowData.HasFlags;+ g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values+ if (window->SkipItems)+ return false;++ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);+ IM_ASSERT((flags & (ImGuiComboFlags_NoArrowButton | ImGuiComboFlags_NoPreview)) != (ImGuiComboFlags_NoArrowButton | ImGuiComboFlags_NoPreview)); // Can't use both flags together+ if (flags & ImGuiComboFlags_WidthFitPreview)+ IM_ASSERT((flags & ImGuiComboFlags_NoPreview) == 0);++ const float arrow_size = (flags & ImGuiComboFlags_NoArrowButton) ? 0.0f : GetFrameHeight();+ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);+ const float preview_width = ((flags & ImGuiComboFlags_WidthFitPreview) && (preview_value != NULL)) ? CalcTextSize(preview_value, NULL, false).x : 0.0f;+ const float w = (flags & ImGuiComboFlags_NoPreview) ? arrow_size : ((flags & ImGuiComboFlags_WidthFitPreview) ? (arrow_size + preview_width + style.FramePadding.x * 2.0f) : CalcItemWidth());+ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y * 2.0f));+ const ImRect total_bb(bb.Min, bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));+ ItemSize(total_bb, style.FramePadding.y);+ if (!ItemAdd(total_bb, id, &bb))+ return false;++ // Open on click+ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held);+ const ImGuiID popup_id = ImHashStr("##ComboPopup", 0, id);+ bool popup_open = IsPopupOpen(popup_id, ImGuiPopupFlags_None);+ if (pressed && !popup_open)+ {+ OpenPopupEx(popup_id, ImGuiPopupFlags_None);+ popup_open = true;+ }++ // Render shape+ const ImU32 frame_col = GetColorU32(hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);+ const float value_x2 = ImMax(bb.Min.x, bb.Max.x - arrow_size);+ RenderNavCursor(bb, id);+ if (BuiOn()) // BUI: Blender menu button (dropdown_draw: wcol_menu, the pulldown arrows, preview text left)+ {+ const bool text = BuiTextOk() && !(flags & ImGuiComboFlags_NoPreview);+ BuiEmit(BuiWidget(BK_WIDGET_MENU, bb, (hovered ? BK_WS_HOVER : 0) | (popup_open ? BK_WS_SELECTED : 0)), text ? preview_value : NULL);+ g.ComboPreviewData.PreviewRect = (flags & ImGuiComboFlags_NoPreview) ? ImRect() : ImRect(bb.Min.x, bb.Min.y, value_x2, bb.Max.y);+ if (preview_value != NULL && !(flags & ImGuiComboFlags_NoPreview) && !text)+ RenderTextClipped(bb.Min + style.FramePadding, ImVec2(value_x2, bb.Max.y), preview_value, NULL, NULL);+ else if (preview_value != NULL && g.LogEnabled)+ LogRenderedText(&bb.Min, preview_value);+ if (label_size.x > 0)+ RenderText(ImVec2(bb.Max.x + style.ItemInnerSpacing.x, bb.Min.y + style.FramePadding.y), label, label_end, false);+ if (!popup_open)+ return false;+ g.NextWindowData.HasFlags = backup_next_window_data_flags;+ return BeginComboPopup(popup_id, bb, flags);+ }+ if (!(flags & ImGuiComboFlags_NoPreview))+ window->DrawList->AddRectFilled(bb.Min, ImVec2(value_x2, bb.Max.y), frame_col, style.FrameRounding, (flags & ImGuiComboFlags_NoArrowButton) ? ImDrawFlags_RoundAll : ImDrawFlags_RoundLeft);+ if (!(flags & ImGuiComboFlags_NoArrowButton))+ {+ ImU32 bg_col = GetColorU32((popup_open || hovered) ? ImGuiCol_ButtonHovered : ImGuiCol_Button);+ ImU32 text_col = GetColorU32(ImGuiCol_Text);+ window->DrawList->AddRectFilled(ImVec2(value_x2, bb.Min.y), bb.Max, bg_col, style.FrameRounding, (w <= arrow_size) ? ImDrawFlags_RoundAll : ImDrawFlags_RoundRight);+ if (value_x2 + arrow_size - style.FramePadding.x <= bb.Max.x)+ RenderArrow(window->DrawList, ImVec2(value_x2 + style.FramePadding.y, bb.Min.y + style.FramePadding.y), text_col, ImGuiDir_Down, 1.0f);+ }+ RenderFrameBorder(bb.Min, bb.Max, style.FrameRounding);++ // Store geometry for BeginComboPreview() - only necessary when visible.+ g.ComboPreviewData.PreviewRect = (flags & ImGuiComboFlags_NoPreview) ? ImRect() : ImRect(bb.Min.x, bb.Min.y, value_x2, bb.Max.y);++ // Render preview and label+ if (preview_value != NULL && !(flags & ImGuiComboFlags_NoPreview))+ {+ if (g.LogEnabled)+ LogSetNextTextDecoration("{", "}");+ RenderTextClipped(bb.Min + style.FramePadding, ImVec2(value_x2, bb.Max.y), preview_value, NULL, NULL);+ }+ if (label_size.x > 0)+ RenderText(ImVec2(bb.Max.x + style.ItemInnerSpacing.x, bb.Min.y + style.FramePadding.y), label, label_end, false);++ if (!popup_open)+ return false;++ g.NextWindowData.HasFlags = backup_next_window_data_flags;+ return BeginComboPopup(popup_id, bb, flags);+}++bool ImGui::BeginComboPopup(ImGuiID popup_id, const ImRect& bb, ImGuiComboFlags flags)+{+ ImGuiContext& g = *GImGui;+ if (!IsPopupOpen(popup_id, ImGuiPopupFlags_None))+ {+ g.NextWindowData.ClearFlags();+ return false;+ }++ // Set popup size+ float w = bb.GetWidth();+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSizeConstraint)+ {+ g.NextWindowData.SizeConstraintRect.Min.x = ImMax(g.NextWindowData.SizeConstraintRect.Min.x, w);+ }+ else+ {+ if ((flags & ImGuiComboFlags_HeightMask_) == 0)+ flags |= ImGuiComboFlags_HeightRegular;+ IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiComboFlags_HeightMask_)); // Only one+ int popup_max_height_in_items = -1;+ if (flags & ImGuiComboFlags_HeightRegular) popup_max_height_in_items = 8;+ else if (flags & ImGuiComboFlags_HeightSmall) popup_max_height_in_items = 4;+ else if (flags & ImGuiComboFlags_HeightLarge) popup_max_height_in_items = 20;+ ImVec2 constraint_min(0.0f, 0.0f), constraint_max(FLT_MAX, FLT_MAX);+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.x <= 0.0f) // Don't apply constraints if user specified a size+ constraint_min.x = w;+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.y <= 0.0f)+ constraint_max.y = CalcMaxPopupHeightFromItemCount(popup_max_height_in_items);+ SetNextWindowSizeConstraints(constraint_min, constraint_max);+ }++ // This is essentially a specialized version of BeginPopupEx()+ char name[16];+ ImFormatString(name, IM_COUNTOF(name), "##Combo_%02d", g.BeginComboDepth); // Recycle windows based on depth++ // Set position given a custom constraint (peak into expected window size so we can position it)+ // FIXME: This might be easier to express with an hypothetical SetNextWindowPosConstraints() function?+ // FIXME: This might be moved to Begin() or at least around the same spot where Tooltips and other Popups are calling FindBestWindowPosForPopupEx()?+ if (ImGuiWindow* popup_window = FindWindowByName(name))+ if (popup_window->WasActive)+ {+ // Always override 'AutoPosLastDirection' to not leave a chance for a past value to affect us.+ ImVec2 size_expected = CalcWindowNextAutoFitSize(popup_window);+ popup_window->AutoPosLastDirection = (flags & ImGuiComboFlags_PopupAlignLeft) ? ImGuiDir_Left : ImGuiDir_Down; // Left = "Below, Toward Left", Down = "Below, Toward Right (default)"+ ImRect r_outer = GetPopupAllowedExtentRect(popup_window);+ ImVec2 pos = FindBestWindowPosForPopupEx(bb.GetBL(), size_expected, &popup_window->AutoPosLastDirection, r_outer, bb, ImGuiPopupPositionPolicy_ComboBox);+ SetNextWindowPos(pos);+ }++ // We don't use BeginPopupEx() solely because we have a custom name string, which we could make an argument to BeginPopupEx()+ ImGuiWindowFlags window_flags = ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_Popup | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoMove;+ PushStyleVarX(ImGuiStyleVar_WindowPadding, g.Style.FramePadding.x); // Horizontally align ourselves with the framed text+ bool ret = Begin(name, NULL, window_flags);+ PopStyleVar();+ if (!ret)+ {+ EndPopup();+ if (!g.IO.ConfigDebugBeginReturnValueOnce && !g.IO.ConfigDebugBeginReturnValueLoop) // Begin may only return false with those debug tools activated.+ IM_ASSERT(0); // This should never happen as we tested for IsPopupOpen() above+ return false;+ }+ g.BeginComboDepth++;+ g.CurrentWindowStack.back().ParentLastComboPreviewRect = g.ComboPreviewData.PreviewRect;+ if (BuiOn()) // BUI: Blender menu backdrop (with its shadow) over ImGui's popup background+ BuiWindowBack(BK_WIDGET_MENU_BACK);+ return true;+}++void ImGui::EndCombo()+{+ ImGuiContext& g = *GImGui;+ g.BeginComboDepth--;+ g.ComboPreviewData.PreviewRect = g.CurrentWindowStack.back().ParentLastComboPreviewRect;+ char name[16];+ ImFormatString(name, IM_COUNTOF(name), "##Combo_%02d", g.BeginComboDepth); // FIXME: Move those to helpers?+ if (strcmp(g.CurrentWindow->Name, name) != 0)+ IM_ASSERT_USER_ERROR_RET(0, "Calling EndCombo() in wrong window!");+ EndPopup();+}++// Submit preview contents for BeginCombo()/EndCombo(), to display contents that's more than just a text label.+// - [BETA] See GitHub issues: #1658, #4168.+// - Make sure you call this after EndCombo().+// - The preview is designed to only host non-interactive elements.+// - Not compatible with ImGuiComboFlags_WidthFitPreview.+// - 2026-09-08 (1.93.0): removed ImGuiComboFlags_CustomPreview. You can use BeginComboPreview()/EndComboPreview() without an extra flag.+bool ImGui::BeginComboPreview()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ if (window->SkipItems || !(g.LastItemData.StatusFlags & ImGuiItemStatusFlags_Visible))+ return false;+ ImGuiComboPreviewData* preview_data = &g.ComboPreviewData;+ if (!window->ClipRect.Overlaps(preview_data->PreviewRect) || preview_data->PreviewRect.GetWidth() <= 0.0f) // Narrower test (optional) + handle _NoPreview+ return false;+ IM_ASSERT_USER_ERROR_RETV(g.LastItemData.Rect.Min.x == preview_data->PreviewRect.Min.x && g.LastItemData.Rect.Min.y == preview_data->PreviewRect.Min.y, false,+ "Call BeginComboPreview() after BeginCombo(), not after EndCombo()!"); // Calling after EndCombo() works only if you don't nest combos.+ IM_ASSERT_USER_ERROR_RETV(preview_data->WithinPreview == false, false,+ "Cannot recurse BeginComboPreview(): call EndComboPreview() before opening another combo.");++ // FIXME: This could be contained in a PushWorkRect() api+ preview_data->BackupCursorPos = window->DC.CursorPos;+ preview_data->BackupCursorMaxPos = window->DC.CursorMaxPos;+ preview_data->BackupCursorPosPrevLine = window->DC.CursorPosPrevLine;+ preview_data->BackupPrevLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;+ preview_data->BackupLayout = window->DC.LayoutType;+ preview_data->WithinPreview = true;+ preview_data->BackupWorkRectMaxX = window->WorkRect.Max.x;+ preview_data->BackupContentRectMaxX = window->ContentRegionRect.Max.x;+ window->WorkRect.Max.x = window->ContentRegionRect.Max.x = preview_data->PreviewRect.Max.x - g.Style.FramePadding.x;+ window->DC.CursorPos = preview_data->PreviewRect.Min + g.Style.FramePadding;+ window->DC.CursorMaxPos = window->DC.CursorPos;+ window->DC.LayoutType = ImGuiLayoutType_Horizontal;+ window->DC.IsSameLine = false;+ PushClipRect(preview_data->PreviewRect.Min, preview_data->PreviewRect.Max, true);++ return true;+}++void ImGui::EndComboPreview()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ ImGuiComboPreviewData* preview_data = &g.ComboPreviewData;++ // FIXME: Using CursorMaxPos approximation instead of correct AABB which we will store in ImDrawCmd in the future+ ImDrawList* draw_list = window->DrawList;+ if (window->DC.CursorMaxPos.x < preview_data->PreviewRect.Max.x && window->DC.CursorMaxPos.y < preview_data->PreviewRect.Max.y)+ if (draw_list->CmdBuffer.Size > 1) // Unlikely case that the PushClipRect() didn't create a command+ {+ draw_list->_CmdHeader.ClipRect = draw_list->CmdBuffer[draw_list->CmdBuffer.Size - 1].ClipRect = draw_list->CmdBuffer[draw_list->CmdBuffer.Size - 2].ClipRect;+ draw_list->_TryMergeDrawCmds();+ }+ PopClipRect();+ window->DC.CursorPos = preview_data->BackupCursorPos;+ window->DC.CursorMaxPos = ImMax(window->DC.CursorMaxPos, preview_data->BackupCursorMaxPos); // No need to do the same with IdealMaxPos+ window->DC.CursorPosPrevLine = preview_data->BackupCursorPosPrevLine;+ window->DC.PrevLineTextBaseOffset = preview_data->BackupPrevLineTextBaseOffset;+ window->WorkRect.Max.x = preview_data->BackupWorkRectMaxX;+ window->ContentRegionRect.Max.x = preview_data->BackupContentRectMaxX;+ window->DC.LayoutType = preview_data->BackupLayout;+ window->DC.IsSameLine = false;+ preview_data->WithinPreview = false;+}++// Getter for the old Combo() API: const char*[]+static const char* Items_ArrayGetter(void* data, int idx)+{+ const char* const* items = (const char* const*)data;+ return items[idx];+}++// Getter for the old Combo() API: "item1\0item2\0item3\0"+static const char* Items_SingleStringGetter(void* data, int idx)+{+ const char* items_separated_by_zeros = (const char*)data;+ int items_count = 0;+ const char* p = items_separated_by_zeros;+ while (*p)+ {+ if (idx == items_count)+ break;+ p += ImStrlen(p) + 1;+ items_count++;+ }+ return *p ? p : NULL;+}++// Old API, prefer using BeginCombo() nowadays if you can.+bool ImGui::Combo(const char* label, int* current_item, const char* (*getter)(void* user_data, int idx), void* user_data, int items_count, int popup_max_height_in_items)+{+ ImGuiContext& g = *GImGui;++ // Call the getter to obtain the preview string which is a parameter to BeginCombo()+ const char* preview_value = NULL;+ if ((g.NextItemData.ItemFlagsSet | g.CurrentItemFlags) & ImGuiItemFlags_MixedValue)+ preview_value = "";+ else if (*current_item >= 0 && *current_item < items_count)+ preview_value = getter(user_data, *current_item);++ // The old Combo() API exposed "popup_max_height_in_items". The new more general BeginCombo() API doesn't have/need it, but we emulate it here.+ if (popup_max_height_in_items != -1 && !(g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSizeConstraint))+ SetNextWindowSizeConstraints(ImVec2(0, 0), ImVec2(FLT_MAX, CalcMaxPopupHeightFromItemCount(popup_max_height_in_items)));++ if (!BeginCombo(label, preview_value, ImGuiComboFlags_None))+ return false;++ // Display items+ bool value_changed = false;+ ImGuiListClipper clipper;+ clipper.Begin(items_count);+ clipper.IncludeItemByIndex(*current_item);+ while (clipper.Step())+ for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)+ {+ const char* item_text = getter(user_data, i);+ if (item_text == NULL)+ item_text = "*Unknown item*";++ PushID(i);+ const bool item_selected = (i == *current_item);+ if (Selectable(item_text, item_selected) && *current_item != i)+ {+ value_changed = true;+ *current_item = i;+ }+ if (item_selected)+ SetItemDefaultFocus();+ PopID();+ }++ EndCombo();+ if (value_changed)+ MarkItemEdited(g.LastItemData.ID);++ return value_changed;+}++// Combo box helper allowing to pass an array of strings.+bool ImGui::Combo(const char* label, int* current_item, const char* const items[], int items_count, int height_in_items)+{+ const bool value_changed = Combo(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_in_items);+ return value_changed;+}++// Combo box helper allowing to pass all items in a single string literal holding multiple zero-terminated items "item1\0item2\0"+bool ImGui::Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int height_in_items)+{+ int items_count = 0;+ const char* p = items_separated_by_zeros; // FIXME-OPT: Avoid computing this, or at least only when combo is open+ while (*p)+ {+ p += ImStrlen(p) + 1;+ items_count++;+ }+ bool value_changed = Combo(label, current_item, Items_SingleStringGetter, (void*)items_separated_by_zeros, items_count, height_in_items);+ return value_changed;+}++//-------------------------------------------------------------------------+// [SECTION] Data Type and Data Formatting Helpers [Internal]+//-------------------------------------------------------------------------+// - DataTypeGetInfo()+// - DataTypeFormatString()+// - DataTypeApplyOp()+// - DataTypeApplyFromText()+// - DataTypeCompare()+// - DataTypeClamp()+// - GetMinimumStepAtDecimalPrecision+// - RoundScalarWithFormat<>()+//-------------------------------------------------------------------------++static const ImU32 GDefaultRgbaColorMarkers[4] =+{+ IM_COL32(240,20,20,255), IM_COL32(20,240,20,255), IM_COL32(20,20,240,255), IM_COL32(140,140,140,255)+};++static const ImGuiDataTypeInfo GDataTypeInfo[] =+{+ { sizeof(char), "S8", "%d", "%d" }, // ImGuiDataType_S8+ { sizeof(unsigned char), "U8", "%u", "%u" },+ { sizeof(short), "S16", "%d", "%d" }, // ImGuiDataType_S16+ { sizeof(unsigned short), "U16", "%u", "%u" },+ { sizeof(int), "S32", "%d", "%d" }, // ImGuiDataType_S32+ { sizeof(unsigned int), "U32", "%u", "%u" },+#ifdef _MSC_VER+ { sizeof(ImS64), "S64", "%I64d","%I64d" }, // ImGuiDataType_S64+ { sizeof(ImU64), "U64", "%I64u","%I64u" },+#else+ { sizeof(ImS64), "S64", "%lld", "%lld" }, // ImGuiDataType_S64+ { sizeof(ImU64), "U64", "%llu", "%llu" },+#endif+ { sizeof(float), "float", "%.3f","%f" }, // ImGuiDataType_Float (float are promoted to double in va_arg)+ { sizeof(double), "double","%f", "%lf" }, // ImGuiDataType_Double+ { sizeof(bool), "bool", "%d", "%d" }, // ImGuiDataType_Bool+ { 0, "char*","%s", "%s" }, // ImGuiDataType_String+};+IM_STATIC_ASSERT(IM_COUNTOF(GDataTypeInfo) == ImGuiDataType_COUNT);++const ImGuiDataTypeInfo* ImGui::DataTypeGetInfo(ImGuiDataType data_type)+{+ IM_ASSERT(data_type >= 0 && data_type < ImGuiDataType_COUNT);+ return &GDataTypeInfo[data_type];+}++int ImGui::DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* p_data, const char* format)+{+ // Signedness doesn't matter when pushing integer arguments+ if (data_type == ImGuiDataType_S32 || data_type == ImGuiDataType_U32)+ return ImFormatString(buf, buf_size, format, *(const ImU32*)p_data);+ if (data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64)+ return ImFormatString(buf, buf_size, format, *(const ImU64*)p_data);+ if (data_type == ImGuiDataType_Float)+ return ImFormatString(buf, buf_size, format, *(const float*)p_data);+ if (data_type == ImGuiDataType_Double)+ return ImFormatString(buf, buf_size, format, *(const double*)p_data);+ if (data_type == ImGuiDataType_S8)+ return ImFormatString(buf, buf_size, format, *(const ImS8*)p_data);+ if (data_type == ImGuiDataType_U8)+ return ImFormatString(buf, buf_size, format, *(const ImU8*)p_data);+ if (data_type == ImGuiDataType_S16)+ return ImFormatString(buf, buf_size, format, *(const ImS16*)p_data);+ if (data_type == ImGuiDataType_U16)+ return ImFormatString(buf, buf_size, format, *(const ImU16*)p_data);+ IM_ASSERT(0);+ return 0;+}++void ImGui::DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, const void* arg1, const void* arg2)+{+ IM_ASSERT(op == '+' || op == '-');+ switch (data_type)+ {+ case ImGuiDataType_S8:+ if (op == '+') { *(ImS8*)output = ImAddClampOverflow(*(const ImS8*)arg1, *(const ImS8*)arg2, IM_S8_MIN, IM_S8_MAX); }+ if (op == '-') { *(ImS8*)output = ImSubClampOverflow(*(const ImS8*)arg1, *(const ImS8*)arg2, IM_S8_MIN, IM_S8_MAX); }+ return;+ case ImGuiDataType_U8:+ if (op == '+') { *(ImU8*)output = ImAddClampOverflow(*(const ImU8*)arg1, *(const ImU8*)arg2, IM_U8_MIN, IM_U8_MAX); }+ if (op == '-') { *(ImU8*)output = ImSubClampOverflow(*(const ImU8*)arg1, *(const ImU8*)arg2, IM_U8_MIN, IM_U8_MAX); }+ return;+ case ImGuiDataType_S16:+ if (op == '+') { *(ImS16*)output = ImAddClampOverflow(*(const ImS16*)arg1, *(const ImS16*)arg2, IM_S16_MIN, IM_S16_MAX); }+ if (op == '-') { *(ImS16*)output = ImSubClampOverflow(*(const ImS16*)arg1, *(const ImS16*)arg2, IM_S16_MIN, IM_S16_MAX); }+ return;+ case ImGuiDataType_U16:+ if (op == '+') { *(ImU16*)output = ImAddClampOverflow(*(const ImU16*)arg1, *(const ImU16*)arg2, IM_U16_MIN, IM_U16_MAX); }+ if (op == '-') { *(ImU16*)output = ImSubClampOverflow(*(const ImU16*)arg1, *(const ImU16*)arg2, IM_U16_MIN, IM_U16_MAX); }+ return;+ case ImGuiDataType_S32:+ if (op == '+') { *(ImS32*)output = ImAddClampOverflow(*(const ImS32*)arg1, *(const ImS32*)arg2, IM_S32_MIN, IM_S32_MAX); }+ if (op == '-') { *(ImS32*)output = ImSubClampOverflow(*(const ImS32*)arg1, *(const ImS32*)arg2, IM_S32_MIN, IM_S32_MAX); }+ return;+ case ImGuiDataType_U32:+ if (op == '+') { *(ImU32*)output = ImAddClampOverflow(*(const ImU32*)arg1, *(const ImU32*)arg2, IM_U32_MIN, IM_U32_MAX); }+ if (op == '-') { *(ImU32*)output = ImSubClampOverflow(*(const ImU32*)arg1, *(const ImU32*)arg2, IM_U32_MIN, IM_U32_MAX); }+ return;+ case ImGuiDataType_S64:+ if (op == '+') { *(ImS64*)output = ImAddClampOverflow(*(const ImS64*)arg1, *(const ImS64*)arg2, IM_S64_MIN, IM_S64_MAX); }+ if (op == '-') { *(ImS64*)output = ImSubClampOverflow(*(const ImS64*)arg1, *(const ImS64*)arg2, IM_S64_MIN, IM_S64_MAX); }+ return;+ case ImGuiDataType_U64:+ if (op == '+') { *(ImU64*)output = ImAddClampOverflow(*(const ImU64*)arg1, *(const ImU64*)arg2, IM_U64_MIN, IM_U64_MAX); }+ if (op == '-') { *(ImU64*)output = ImSubClampOverflow(*(const ImU64*)arg1, *(const ImU64*)arg2, IM_U64_MIN, IM_U64_MAX); }+ return;+ case ImGuiDataType_Float:+ if (op == '+') { *(float*)output = *(const float*)arg1 + *(const float*)arg2; }+ if (op == '-') { *(float*)output = *(const float*)arg1 - *(const float*)arg2; }+ return;+ case ImGuiDataType_Double:+ if (op == '+') { *(double*)output = *(const double*)arg1 + *(const double*)arg2; }+ if (op == '-') { *(double*)output = *(const double*)arg1 - *(const double*)arg2; }+ return;+ case ImGuiDataType_COUNT: break;+ }+ IM_ASSERT(0);+}++// User can input math operators (e.g. +100) to edit a numerical values.+// NB: This is _not_ a full expression evaluator. We should probably add one and replace this dumb mess..+bool ImGui::DataTypeApplyFromText(const char* buf, ImGuiDataType data_type, void* p_data, const char* format, void* p_data_when_empty)+{+ // Copy the value in an opaque buffer so we can compare at the end of the function if it changed at all.+ const ImGuiDataTypeInfo* type_info = DataTypeGetInfo(data_type);+ ImGuiDataTypeStorage data_backup;+ memcpy(&data_backup, p_data, type_info->Size);++ while (ImCharIsBlankA(*buf))+ buf++;+ if (!buf[0])+ {+ if (p_data_when_empty != NULL)+ {+ memcpy(p_data, p_data_when_empty, type_info->Size);+ return memcmp(&data_backup, p_data, type_info->Size) != 0;+ }+ return false;+ }++ // Sanitize format+ // - For float/double we have to ignore format with precision (e.g. "%.2f") because sscanf doesn't take them in, so force them into %f and %lf+ char format_sanitized[32];+ if (data_type == ImGuiDataType_Float || data_type == ImGuiDataType_Double)+ {+ format = type_info->ScanFmt;+ }+ else+ {+ format = ImParseFormatSanitizeForScanning(format, format_sanitized, IM_COUNTOF(format_sanitized));+ if (format[0] == '\0')+ format = type_info->ScanFmt; // Format doesn't want us to show the number currently, but we still need to parse the resulting input+ }++ // Small types need a 32-bit buffer to receive the result from scanf()+ int v32 = 0;+ if (sscanf(buf, format, type_info->Size >= 4 ? p_data : &v32) < 1)+ return false;+ if (type_info->Size < 4)+ {+ if (data_type == ImGuiDataType_S8)+ *(ImS8*)p_data = (ImS8)ImClamp(v32, (int)IM_S8_MIN, (int)IM_S8_MAX);+ else if (data_type == ImGuiDataType_U8)+ *(ImU8*)p_data = (ImU8)ImClamp(v32, (int)IM_U8_MIN, (int)IM_U8_MAX);+ else if (data_type == ImGuiDataType_S16)+ *(ImS16*)p_data = (ImS16)ImClamp(v32, (int)IM_S16_MIN, (int)IM_S16_MAX);+ else if (data_type == ImGuiDataType_U16)+ *(ImU16*)p_data = (ImU16)ImClamp(v32, (int)IM_U16_MIN, (int)IM_U16_MAX);+ else+ IM_ASSERT(0);+ }++ return memcmp(&data_backup, p_data, type_info->Size) != 0;+}++template<typename T>+static int DataTypeCompareT(const T* lhs, const T* rhs)+{+ if (*lhs < *rhs) return -1;+ if (*lhs > *rhs) return +1;+ return 0;+}++int ImGui::DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2)+{+ switch (data_type)+ {+ case ImGuiDataType_S8: return DataTypeCompareT<ImS8 >((const ImS8* )arg_1, (const ImS8* )arg_2);+ case ImGuiDataType_U8: return DataTypeCompareT<ImU8 >((const ImU8* )arg_1, (const ImU8* )arg_2);+ case ImGuiDataType_S16: return DataTypeCompareT<ImS16 >((const ImS16* )arg_1, (const ImS16* )arg_2);+ case ImGuiDataType_U16: return DataTypeCompareT<ImU16 >((const ImU16* )arg_1, (const ImU16* )arg_2);+ case ImGuiDataType_S32: return DataTypeCompareT<ImS32 >((const ImS32* )arg_1, (const ImS32* )arg_2);+ case ImGuiDataType_U32: return DataTypeCompareT<ImU32 >((const ImU32* )arg_1, (const ImU32* )arg_2);+ case ImGuiDataType_S64: return DataTypeCompareT<ImS64 >((const ImS64* )arg_1, (const ImS64* )arg_2);+ case ImGuiDataType_U64: return DataTypeCompareT<ImU64 >((const ImU64* )arg_1, (const ImU64* )arg_2);+ case ImGuiDataType_Float: return DataTypeCompareT<float >((const float* )arg_1, (const float* )arg_2);+ case ImGuiDataType_Double: return DataTypeCompareT<double>((const double*)arg_1, (const double*)arg_2);+ case ImGuiDataType_COUNT: break;+ }+ IM_ASSERT(0);+ return 0;+}++template<typename T>+static bool DataTypeClampT(T* v, const T* v_min, const T* v_max)+{+ // Clamp, both sides are optional, return true if modified+ if (v_min && *v < *v_min) { *v = *v_min; return true; }+ if (v_max && *v > *v_max) { *v = *v_max; return true; }+ return false;+}++bool ImGui::DataTypeClamp(ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max)+{+ switch (data_type)+ {+ case ImGuiDataType_S8: return DataTypeClampT<ImS8 >((ImS8* )p_data, (const ImS8* )p_min, (const ImS8* )p_max);+ case ImGuiDataType_U8: return DataTypeClampT<ImU8 >((ImU8* )p_data, (const ImU8* )p_min, (const ImU8* )p_max);+ case ImGuiDataType_S16: return DataTypeClampT<ImS16 >((ImS16* )p_data, (const ImS16* )p_min, (const ImS16* )p_max);+ case ImGuiDataType_U16: return DataTypeClampT<ImU16 >((ImU16* )p_data, (const ImU16* )p_min, (const ImU16* )p_max);+ case ImGuiDataType_S32: return DataTypeClampT<ImS32 >((ImS32* )p_data, (const ImS32* )p_min, (const ImS32* )p_max);+ case ImGuiDataType_U32: return DataTypeClampT<ImU32 >((ImU32* )p_data, (const ImU32* )p_min, (const ImU32* )p_max);+ case ImGuiDataType_S64: return DataTypeClampT<ImS64 >((ImS64* )p_data, (const ImS64* )p_min, (const ImS64* )p_max);+ case ImGuiDataType_U64: return DataTypeClampT<ImU64 >((ImU64* )p_data, (const ImU64* )p_min, (const ImU64* )p_max);+ case ImGuiDataType_Float: return DataTypeClampT<float >((float* )p_data, (const float* )p_min, (const float* )p_max);+ case ImGuiDataType_Double: return DataTypeClampT<double>((double*)p_data, (const double*)p_min, (const double*)p_max);+ case ImGuiDataType_COUNT: break;+ }+ IM_ASSERT(0);+ return false;+}++bool ImGui::DataTypeIsZero(ImGuiDataType data_type, const void* p_data)+{+ ImGuiContext& g = *GImGui;+ return DataTypeCompare(data_type, p_data, &g.DataTypeZeroValue) == 0;+}++static float GetMinimumStepAtDecimalPrecision(int decimal_precision)+{+ static const float min_steps[10] = { 1.0f, 0.1f, 0.01f, 0.001f, 0.0001f, 0.00001f, 0.000001f, 0.0000001f, 0.00000001f, 0.000000001f };+ if (decimal_precision < 0)+ return FLT_MIN;+ return (decimal_precision < IM_COUNTOF(min_steps)) ? min_steps[decimal_precision] : ImPow(10.0f, (float)-decimal_precision);+}++template<typename TYPE>+TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)+{+ IM_UNUSED(data_type);+ IM_ASSERT(data_type == ImGuiDataType_Float || data_type == ImGuiDataType_Double);+ const char* fmt_start = ImParseFormatFindStart(format);+ if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string+ return v;++ // Sanitize format+ char fmt_sanitized[32];+ ImParseFormatSanitizeForPrinting(fmt_start, fmt_sanitized, IM_COUNTOF(fmt_sanitized));+ fmt_start = fmt_sanitized;++ // Format value with our rounding, and read back+ char v_str[64];+ ImFormatString(v_str, IM_COUNTOF(v_str), fmt_start, v);+ const char* p = v_str;+ while (*p == ' ')+ p++;+ v = (TYPE)ImAtof(p);++ return v;+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: DragScalar, DragFloat, DragInt, etc.+//-------------------------------------------------------------------------+// - DragBehaviorT<>() [Internal]+// - DragBehavior() [Internal]+// - DragScalar()+// - DragScalarN()+// - DragFloat()+// - DragFloat2()+// - DragFloat3()+// - DragFloat4()+// - DragFloatRange2()+// - DragInt()+// - DragInt2()+// - DragInt3()+// - DragInt4()+// - DragIntRange2()+//-------------------------------------------------------------------------++// This is called by DragBehavior() when the widget is active (held by mouse or being manipulated with Nav controls)+template<typename TYPE, typename SIGNEDTYPE, typename FLOATTYPE>+bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags)+{+ ImGuiContext& g = *GImGui;+ const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;+ const bool is_bounded = (v_min < v_max) || ((v_min == v_max) && (v_min != 0.0f || (flags & ImGuiSliderFlags_ClampZeroRange)));+ const bool is_wrapped = is_bounded && (flags & ImGuiSliderFlags_WrapAround);+ const bool is_logarithmic = (flags & ImGuiSliderFlags_Logarithmic) != 0;+ const bool is_floating_point = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);++ // Default tweak speed+ if (v_speed == 0.0f && is_bounded && (v_max - v_min < FLT_MAX))+ v_speed = (float)((v_max - v_min) * g.DragSpeedDefaultRatio);++ // Inputs accumulates into g.DragCurrentAccum, which is flushed into the current value as soon as it makes a difference with our precision settings+ float adjust_delta = 0.0f;+ if (g.ActiveIdSource == ImGuiInputSource_Mouse && IsMousePosValid() && IsMouseDragPastThreshold(0, g.IO.MouseDragThreshold * DRAG_MOUSE_THRESHOLD_FACTOR))+ {+ adjust_delta = g.IO.MouseDelta[axis];+ if (g.IO.KeyAlt && !(flags & ImGuiSliderFlags_NoSpeedTweaks))+ adjust_delta *= 1.0f / 100.0f;+ if (g.IO.KeyShift && !(flags & ImGuiSliderFlags_NoSpeedTweaks))+ adjust_delta *= 10.0f;+ }+ else if (g.ActiveIdSource == ImGuiInputSource_Keyboard || g.ActiveIdSource == ImGuiInputSource_Gamepad)+ {+ const int decimal_precision = is_floating_point ? ImParseFormatPrecision(format, 3) : 0;+ const bool tweak_slow = IsKeyDown((g.NavInputSource == ImGuiInputSource_Gamepad) ? ImGuiKey_NavGamepadTweakSlow : ImGuiKey_NavKeyboardTweakSlow);+ const bool tweak_fast = IsKeyDown((g.NavInputSource == ImGuiInputSource_Gamepad) ? ImGuiKey_NavGamepadTweakFast : ImGuiKey_NavKeyboardTweakFast);+ const float tweak_factor = (flags & ImGuiSliderFlags_NoSpeedTweaks) ? 1.0f : tweak_slow ? 1.0f / 10.0f : tweak_fast ? 10.0f : 1.0f;+ adjust_delta = GetNavTweakPressedAmount(axis) * tweak_factor;+ v_speed = ImMax(v_speed, GetMinimumStepAtDecimalPrecision(decimal_precision));+ }+ adjust_delta *= v_speed;++ // For vertical drag we currently assume that Up=higher value (like we do with vertical sliders). This may become a parameter.+ if (axis == ImGuiAxis_Y)+ adjust_delta = -adjust_delta;++ // For logarithmic use our range is effectively 0..1 so scale the delta into that range+ if (is_logarithmic && (v_max - v_min < FLT_MAX) && ((v_max - v_min) > 0.000001f)) // Epsilon to avoid /0+ adjust_delta /= (float)(v_max - v_min);++ // Clear current value on activation+ // Avoid altering values and clamping when we are _already_ past the limits and heading in the same direction, so e.g. if range is 0..255, current value is 300 and we are pushing to the right side, keep the 300.+ const bool is_just_activated = g.ActiveIdIsJustActivated;+ const bool is_already_past_limits_and_pushing_outward = is_bounded && !is_wrapped && ((*v >= v_max && adjust_delta > 0.0f) || (*v <= v_min && adjust_delta < 0.0f));+ if (is_just_activated || is_already_past_limits_and_pushing_outward)+ {+ g.DragCurrentAccum = 0.0f;+ g.DragCurrentAccumDirty = false;+ }+ else if (adjust_delta != 0.0f)+ {+ g.DragCurrentAccum += adjust_delta;+ g.DragCurrentAccumDirty = true;+ }++ if (!g.DragCurrentAccumDirty)+ return false;++ TYPE v_cur = *v;+ FLOATTYPE v_old_ref_for_accum_remainder = (FLOATTYPE)0.0f;++ float logarithmic_zero_epsilon = 0.0f; // Only valid when is_logarithmic is true+ const float zero_deadzone_halfsize = 0.0f; // Drag widgets have no deadzone (as it doesn't make sense)+ if (is_logarithmic)+ {+ // When using logarithmic sliders, we need to clamp to avoid hitting zero, but our choice of clamp value greatly affects slider precision. We attempt to use the specified precision to estimate a good lower bound.+ const int decimal_precision = is_floating_point ? ImParseFormatPrecision(format, 3) : 1;+ logarithmic_zero_epsilon = ImPow(0.1f, (float)decimal_precision);++ // Convert to parametric space, apply delta, convert back+ float v_old_parametric = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_cur, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);+ float v_new_parametric = v_old_parametric + g.DragCurrentAccum;+ v_cur = ScaleValueFromRatioT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_new_parametric, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);+ v_old_ref_for_accum_remainder = v_old_parametric;+ }+ else+ {+ v_cur += (SIGNEDTYPE)g.DragCurrentAccum;+ }++ // Round to user desired precision based on format string+ if (is_floating_point && !(flags & ImGuiSliderFlags_NoRoundToFormat))+ v_cur = RoundScalarWithFormatT<TYPE>(format, data_type, v_cur);++ // Preserve remainder after rounding has been applied. This also allow slow tweaking of values.+ g.DragCurrentAccumDirty = false;+ if (is_logarithmic)+ {+ // Convert to parametric space, apply delta, convert back+ float v_new_parametric = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_cur, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);+ g.DragCurrentAccum -= (float)(v_new_parametric - v_old_ref_for_accum_remainder);+ }+ else+ {+ g.DragCurrentAccum -= (float)((SIGNEDTYPE)v_cur - (SIGNEDTYPE)*v);+ }++ // Lose zero sign for float/double+ if (v_cur == (TYPE)-0)+ v_cur = (TYPE)0;++ if (*v != v_cur && is_bounded)+ {+ if (is_wrapped)+ {+ // Wrap values+ if (v_cur < v_min)+ v_cur += v_max - v_min + (is_floating_point ? 0 : 1);+ if (v_cur > v_max)+ v_cur -= v_max - v_min + (is_floating_point ? 0 : 1);+ }+ else+ {+ // Clamp values + handle overflow/wrap-around for integer types.+ if (v_cur < v_min || (v_cur > *v && adjust_delta < 0.0f && !is_floating_point))+ v_cur = v_min;+ if (v_cur > v_max || (v_cur < *v && adjust_delta > 0.0f && !is_floating_point))+ v_cur = v_max;+ }+ }++ // Apply result+ if (*v == v_cur)+ return false;+ *v = v_cur;+ return true;+}++static bool ShortcutsForCancel(ImGuiID id)+{+ ImGuiContext& g = *GImGui;+ bool is_cancel_with_keyboard = ImGui::Shortcut(ImGuiKey_Escape, ImGuiInputFlags_None, id);+ bool is_cancel_with_gamepad = (g.IO.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) != 0 && (g.IO.BackendFlags & ImGuiBackendFlags_HasGamepad) != 0 && ImGui::Shortcut(ImGuiKey_NavGamepadCancel, ImGuiInputFlags_None, id);+ bool is_cancel_with_mouse = ImGui::IsMouseReleased(ImGuiMouseButton_Right, id);+ if (is_cancel_with_mouse)+ ImGui::SetKeyOwner(ImGuiKey_MouseRight, id);+ return is_cancel_with_keyboard || is_cancel_with_gamepad || is_cancel_with_mouse;+}++bool ImGui::DragBehavior(ImGuiID id, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)+{+ // Read imgui.cpp "API BREAKING CHANGES" section for 1.78 if you hit this assert.+ IM_ASSERT((flags == 1 || (flags & ImGuiSliderFlags_InvalidMask_) == 0) && "Invalid ImGuiSliderFlags flags! Has the legacy 'float power' argument been mistakenly cast to flags? Call function with ImGuiSliderFlags_Logarithmic flags instead.");++ // Things we can do easily outside the DragBehaviorT<> template, saves code generation.+ ImGuiContext& g = *GImGui;+ if (g.ActiveId == id)+ {+ if (g.ActiveIdSource == ImGuiInputSource_Mouse && !g.IO.MouseDown[0])+ ClearActiveID();+ else if ((g.ActiveIdSource == ImGuiInputSource_Keyboard || g.ActiveIdSource == ImGuiInputSource_Gamepad) && g.NavActivatePressedId == id && !g.ActiveIdIsJustActivated)+ ClearActiveID();+ if (ShortcutsForCancel(id) && g.ActiveId == id) //-V560+ {+ // Canceling action reverts to initial value+ size_t data_size = DataTypeGetInfo(data_type)->Size;+ bool value_changed = memcmp(p_v, &g.ActiveIdValueOnActivation, data_size) != 0;+ memcpy(p_v, &g.ActiveIdValueOnActivation, data_size);+ ClearActiveID();+ return value_changed;+ }+ }+ if (g.ActiveId != id)+ return false;+ if ((g.LastItemData.ItemFlags & ImGuiItemFlags_ReadOnly) || (flags & ImGuiSliderFlags_ReadOnly))+ return false;++ switch (data_type)+ {+ case ImGuiDataType_S8: { ImS32 v32 = (ImS32)*(ImS8*)p_v; bool r = DragBehaviorT<ImS32, ImS32, float>(ImGuiDataType_S32, &v32, v_speed, p_min ? *(const ImS8*) p_min : IM_S8_MIN, p_max ? *(const ImS8*)p_max : IM_S8_MAX, format, flags); if (r) *(ImS8*)p_v = (ImS8)v32; return r; }+ case ImGuiDataType_U8: { ImU32 v32 = (ImU32)*(ImU8*)p_v; bool r = DragBehaviorT<ImU32, ImS32, float>(ImGuiDataType_U32, &v32, v_speed, p_min ? *(const ImU8*) p_min : IM_U8_MIN, p_max ? *(const ImU8*)p_max : IM_U8_MAX, format, flags); if (r) *(ImU8*)p_v = (ImU8)v32; return r; }+ case ImGuiDataType_S16: { ImS32 v32 = (ImS32)*(ImS16*)p_v; bool r = DragBehaviorT<ImS32, ImS32, float>(ImGuiDataType_S32, &v32, v_speed, p_min ? *(const ImS16*)p_min : IM_S16_MIN, p_max ? *(const ImS16*)p_max : IM_S16_MAX, format, flags); if (r) *(ImS16*)p_v = (ImS16)v32; return r; }+ case ImGuiDataType_U16: { ImU32 v32 = (ImU32)*(ImU16*)p_v; bool r = DragBehaviorT<ImU32, ImS32, float>(ImGuiDataType_U32, &v32, v_speed, p_min ? *(const ImU16*)p_min : IM_U16_MIN, p_max ? *(const ImU16*)p_max : IM_U16_MAX, format, flags); if (r) *(ImU16*)p_v = (ImU16)v32; return r; }+ case ImGuiDataType_S32: return DragBehaviorT<ImS32, ImS32, float >(data_type, (ImS32*)p_v, v_speed, p_min ? *(const ImS32* )p_min : IM_S32_MIN, p_max ? *(const ImS32* )p_max : IM_S32_MAX, format, flags);+ case ImGuiDataType_U32: return DragBehaviorT<ImU32, ImS32, float >(data_type, (ImU32*)p_v, v_speed, p_min ? *(const ImU32* )p_min : IM_U32_MIN, p_max ? *(const ImU32* )p_max : IM_U32_MAX, format, flags);+ case ImGuiDataType_S64: return DragBehaviorT<ImS64, ImS64, double>(data_type, (ImS64*)p_v, v_speed, p_min ? *(const ImS64* )p_min : IM_S64_MIN, p_max ? *(const ImS64* )p_max : IM_S64_MAX, format, flags);+ case ImGuiDataType_U64: return DragBehaviorT<ImU64, ImS64, double>(data_type, (ImU64*)p_v, v_speed, p_min ? *(const ImU64* )p_min : IM_U64_MIN, p_max ? *(const ImU64* )p_max : IM_U64_MAX, format, flags);+ case ImGuiDataType_Float: return DragBehaviorT<float, float, float >(data_type, (float*)p_v, v_speed, p_min ? *(const float* )p_min : -FLT_MAX, p_max ? *(const float* )p_max : FLT_MAX, format, flags);+ case ImGuiDataType_Double: return DragBehaviorT<double,double,double>(data_type, (double*)p_v, v_speed, p_min ? *(const double*)p_min : -DBL_MAX, p_max ? *(const double*)p_max : DBL_MAX, format, flags);+ case ImGuiDataType_COUNT: break;+ }+ IM_ASSERT(0);+ return false;+}++// Only clamp Ctrl+Click input when ImGuiSliderFlags_ClampOnInput is set (generally via ImGuiSliderFlags_AlwaysClamp)+static bool TempInputIsClampEnabled(ImGuiSliderFlags flags, ImGuiDataType data_type, const void* p_min, const void* p_max)+{+ if ((flags & ImGuiSliderFlags_ClampOnInput) && (p_min != NULL || p_max != NULL))+ {+ const int clamp_range_dir = (p_min != NULL && p_max != NULL) ? ImGui::DataTypeCompare(data_type, p_min, p_max) : 0; // -1 when *p_min < *p_max, == 0 when *p_min == *p_max+ if (p_min == NULL || p_max == NULL || clamp_range_dir < 0)+ return true;+ if (clamp_range_dir == 0)+ return ImGui::DataTypeIsZero(data_type, p_min) ? ((flags & ImGuiSliderFlags_ClampZeroRange) != 0) : true;+ }+ return false;+}++// BUI: Blender's number field / number slider interaction (interface_handlers.cc:+// ui_do_but_NUM / ui_do_but_SLI, as the kit's kit_widgets.c number_* functions):+// - press and release without moving: the step arrows step (number fields), elsewhere the+// value is typed (text editing); Ctrl+click / double-click type too (ImGui's own path);+// - drag (past 0.25 widget units): number fields move v_speed per pixel (ImGui's API+// speed, Blender's "one step per pixel"), sliders follow the pointer over their width+// relative to where the drag began (no jump to the click position);+// - Shift: precision (number: 1/10 the speed, slider: 1/20), restarting from the current+// value so it does not jump; Ctrl: snapping (numedit_apply_snapf / numedit_but_SLI),+// Ctrl+Shift finer; Escape reverts.+static inline double BuiRound(double v) { return floor(v + 0.5); }++static double BuiGetValue(ImGuiDataType t, const void* p)+{+ switch (t)+ {+ case ImGuiDataType_S8: return *(const ImS8*)p;+ case ImGuiDataType_U8: return *(const ImU8*)p;+ case ImGuiDataType_S16: return *(const ImS16*)p;+ case ImGuiDataType_U16: return *(const ImU16*)p;+ case ImGuiDataType_S32: return *(const ImS32*)p;+ case ImGuiDataType_U32: return *(const ImU32*)p;+ case ImGuiDataType_S64: return (double)*(const ImS64*)p;+ case ImGuiDataType_U64: return (double)*(const ImU64*)p;+ case ImGuiDataType_Float: return *(const float*)p;+ case ImGuiDataType_Double: return *(const double*)p;+ default: return 0.0;+ }+}++static bool BuiSetValue(ImGuiDataType t, void* p, double v)+{+ if (t != ImGuiDataType_Float && t != ImGuiDataType_Double)+ v = floor(v + 0.5);+ char before[8];+ const size_t size = ImGui::DataTypeGetInfo(t)->Size;+ memcpy(before, p, size);+ switch (t)+ {+ case ImGuiDataType_S8: *(ImS8*)p = (ImS8)ImClamp(v, (double)IM_S8_MIN, (double)IM_S8_MAX); break;+ case ImGuiDataType_U8: *(ImU8*)p = (ImU8)ImClamp(v, (double)IM_U8_MIN, (double)IM_U8_MAX); break;+ case ImGuiDataType_S16: *(ImS16*)p = (ImS16)ImClamp(v, (double)IM_S16_MIN, (double)IM_S16_MAX); break;+ case ImGuiDataType_U16: *(ImU16*)p = (ImU16)ImClamp(v, (double)IM_U16_MIN, (double)IM_U16_MAX); break;+ case ImGuiDataType_S32: *(ImS32*)p = (ImS32)ImClamp(v, (double)IM_S32_MIN, (double)IM_S32_MAX); break;+ case ImGuiDataType_U32: *(ImU32*)p = (ImU32)ImClamp(v, (double)IM_U32_MIN, (double)IM_U32_MAX); break;+ case ImGuiDataType_S64: *(ImS64*)p = (ImS64)ImClamp(v, -9.2e18, 9.2e18); break;+ case ImGuiDataType_U64: *(ImU64*)p = (ImU64)ImClamp(v, 0.0, 1.8e19); break;+ case ImGuiDataType_Float: *(float*)p = (float)v; break;+ case ImGuiDataType_Double: *(double*)p = v; break;+ default: break;+ }+ return memcmp(before, p, size) != 0;+}++static bool BuiIsInt(ImGuiDataType t) { return t != ImGuiDataType_Float && t != ImGuiDataType_Double; }++// snap_float / snap (kit_widgets.c)+static double BuiSnapFloat(double v, double range, bool small)+{+ const double f = small ? 0.1 : 1.0;+ if (range < 2.10)+ return BuiRound(v * 10.0 / f) * 0.1 * f;+ if (range < 21.0)+ return BuiRound(v / f) * f;+ return BuiRound(v * 0.1 / f) * 10.0 * f;+}++static double BuiSnap(double v, double vmin, double vmax, bool bounded, bool is_int, bool slider, bool degrees)+{+ ImGuiContext& g = *GImGui;+ if (!g.IO.KeyCtrl || (bounded && (v == vmin || v == vmax)))+ return v;+ const bool small = g.IO.KeyShift;+ if (is_int)+ {+ const long long t = (long long)v, m = small ? 100 : 10;+ return (double)(m * (t / m));+ }+ double range = bounded ? vmax - vmin : 20.0;+ if (slider)+ return small ? (range < 2.10 ? BuiRound(v * 100.0) * 0.01 : (range < 21.0 ? BuiRound(v * 10.0) * 0.1 : (double)BuiRound(v))) : BuiSnapFloat(v, range, false);+ if (range >= 21.0 && !degrees) // too coarse for unbounded floats, allowed for degrees+ range = 20.0;+ return BuiSnapFloat(v, range, small);+}++struct BuiNumState+{+ ImGuiContext* Ctx;+ ImGuiID Id;+ double Start, Orig;+ float X0, F0;+ bool Dragging, Shift;+};+static BuiNumState g_BuiNum = {};++// The mouse interaction of an active number field (slider=false) or slider. Returns true when+// the value changed; *r_text_edit when a click asks for typing.+static bool BuiNumberBehavior(ImGuiID id, const ImRect& bb, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, bool slider, bool* r_text_edit)+{+ ImGuiContext& g = *GImGui;+ *r_text_edit = false;+ const double v = BuiGetValue(data_type, p_v);+ if (g_BuiNum.Id != id || g_BuiNum.Ctx != &g)+ {+ g_BuiNum.Ctx = &g;+ g_BuiNum.Id = id;+ g_BuiNum.Start = g_BuiNum.Orig = v;+ g_BuiNum.Dragging = false;+ g_BuiNum.Shift = g.IO.KeyShift;+ }+ if (ShortcutsForCancel(id) && g.ActiveId == id)+ {+ const bool changed = BuiSetValue(data_type, p_v, g_BuiNum.Orig);+ ImGui::ClearActiveID();+ g_BuiNum.Id = 0;+ return changed;+ }+ const bool read_only = (g.LastItemData.ItemFlags & ImGuiItemFlags_ReadOnly) || (flags & ImGuiSliderFlags_ReadOnly);+ const bool is_int = BuiIsInt(data_type);+ double vmin = p_min ? BuiGetValue(data_type, p_min) : -DBL_MAX, vmax = p_max ? BuiGetValue(data_type, p_max) : DBL_MAX;+ const bool bounded = p_min && p_max && vmin < vmax;+ if (!bounded)+ vmin = -DBL_MAX, vmax = DBL_MAX;+ const bool degrees = format && (strstr(format, "deg") || strstr(format, "\xc2\xb0"));+ double speed = v_speed;+ if (speed == 0.0f && bounded && vmax - vmin < FLT_MAX)+ speed = (vmax - vmin) * g.DragSpeedDefaultRatio;+ if (speed == 0.0)+ speed = is_int ? 1.0 : 0.01;+ const float unit = ImMax(bb.GetHeight(), 1.0f); // the widget unit+ const float mx = g.IO.MousePos.x;++ if (!g.IO.MouseDown[0]) // released+ {+ const bool dragged = g_BuiNum.Dragging;+ g_BuiNum.Id = 0;+ if (dragged || read_only)+ {+ ImGui::ClearActiveID();+ return false;+ }+ if (!slider && bb.Contains(g.IO.MousePos))+ {+ const float aw = ImMin(bb.GetWidth() / 3.0f, (float)(int)(bb.GetHeight() * 0.7f)); // handle_width+ const int dir = mx < bb.Min.x + aw ? -1 : mx >= bb.Max.x - aw ? +1 : 0;+ if (dir != 0) // number_step: the click step+ {+ ImGui::ClearActiveID();+ const double step = is_int ? ImMax(1.0, (double)BuiRound(speed)) : speed;+ return BuiSetValue(data_type, p_v, ImClamp(v + dir * step, vmin, vmax));+ }+ }+ if ((flags & ImGuiSliderFlags_NoInput) == 0)+ *r_text_edit = true; // stays active: the text field takes over+ else+ ImGui::ClearActiveID();+ return false;+ }+ if (read_only)+ return false;++ if (!g_BuiNum.Dragging)+ {+ // DRAG_MULTINUM_THRESHOLD_DRAG_Y: decided once the drag is longer than 0.25 units+ const ImVec2 d = g.IO.MousePos - g.IO.MouseClickedPos[0];+ const float margin = 0.25f * unit;+ if (d.x * d.x + d.y * d.y <= margin * margin)+ return false;+ g_BuiNum.Dragging = true;+ const float th = ImMax(3.0f, 0.15f * unit); // drag_origin: the press, past the threshold+ g_BuiNum.X0 = g.IO.MouseClickedPos[0].x + ImClamp(d.x, -th, th);+ g_BuiNum.Start = v;+ g_BuiNum.F0 = bounded ? (float)((v - vmin) / (vmax - vmin)) : 0.0f;+ g_BuiNum.Shift = g.IO.KeyShift;+ }+ if (g.IO.KeyShift != g_BuiNum.Shift) // a Shift press or release restarts from here+ {+ g_BuiNum.Shift = g.IO.KeyShift;+ g_BuiNum.Start = v;+ g_BuiNum.F0 = bounded ? (float)((v - vmin) / (vmax - vmin)) : 0.0f;+ g_BuiNum.X0 = mx;+ }+ double t;+ if (slider && bounded) // slider_drag_value+ {+ const double fac = g.IO.KeyShift ? 0.05 : 1.0;+ const double mx_fl = g_BuiNum.X0 * (1.0 - fac) + mx * fac;+ const double f = ImClamp((mx_fl - g_BuiNum.X0) / ImMax(bb.GetWidth(), 1.0f) + g_BuiNum.F0, 0.0, 1.0);+ t = vmin + f * (vmax - vmin);+ if (is_int)+ t = (double)BuiRound(t);+ t = BuiSnap(t, vmin, vmax, bounded, is_int, true, degrees);+ }+ else // number_drag_value+ {+ const double fac = speed * (g.IO.KeyShift ? 0.1 : 1.0);+ t = g_BuiNum.Start + (mx - g_BuiNum.X0) * fac;+ if (is_int)+ t = (double)(long long)t;+ t = BuiSnap(t, vmin, vmax, bounded, is_int, false, degrees);+ if (t < vmin) // past a limit the start point moves: dragging back responds at once+ {+ g_BuiNum.X0 -= (float)((vmin - t) / fac);+ t = vmin;+ }+ else if (t > vmax)+ {+ g_BuiNum.X0 += (float)((t - vmax) / fac);+ t = vmax;+ }+ }+ if (!is_int && format && !(flags & ImGuiSliderFlags_NoRoundToFormat))+ t = ImGui::RoundScalarWithFormatT<double>(format, ImGuiDataType_Double, t);+ return BuiSetValue(data_type, p_v, t);+}++// The value text of a number field / slider: "Label: value" formats (e.g. "R:%3d") show+// Blender's way, the label left and the value right; others are centered.+static void BuiNumberEmit(int kind, const ImRect& bb, int state, const char* text, const char* text_end, float factor)+{+ BKWidgetDraw w = BuiWidget(kind, bb, state);+ w.value = factor;+ if (!BuiTextOk())+ {+ BuiEmit(w);+ RenderTextClipped(bb.Min, bb.Max, text, text_end, NULL, ImVec2(0.5f, 0.5f));+ return;+ }+ const char* colon = (const char*)ImMemchr(text, ':', text_end - text);+ if (colon && colon > text)+ {+ const char* value = colon + 1;+ while (value < text_end && *value == ' ')+ value++;+ BuiEmit(w, text, colon, value, text_end);+ return;+ }+ BuiEmit(w, NULL, NULL, text, text_end);+}++// Note: p_data, p_min and p_max are _pointers_ to a memory address holding the data. For a Drag widget, p_min and p_max are optional.+// Read code of e.g. DragFloat(), DragInt() etc. or examples in 'Demo->Widgets->Data Types' to understand how to use this function directly.+bool ImGui::DragScalar(const char* label, ImGuiDataType data_type, void* p_data, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);+ const float w = CalcItemWidth();+ const ImU32 color_marker = (g.NextItemData.HasFlags & ImGuiNextItemDataFlags_HasColorMarker) ? g.NextItemData.ColorMarker : 0;++ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);+ const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y * 2.0f));+ const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));++ const bool temp_input_allowed = (flags & ImGuiSliderFlags_NoInput) == 0;+ ItemSize(total_bb, style.FramePadding.y);+ if (!ItemAdd(total_bb, id, &frame_bb, temp_input_allowed ? ImGuiItemFlags_Inputable : 0))+ return false;++ // Default format string when passing NULL+ if (format == NULL)+ format = DataTypeGetInfo(data_type)->PrintFmt;++ const bool hovered = ItemHoverable(frame_bb, id, g.LastItemData.ItemFlags);+ bool temp_input_is_active = temp_input_allowed && TempInputIsActive(id);+ if (!temp_input_is_active)+ {+ // Tabbing or Ctrl+Click on Drag turns it into an InputText+ const bool clicked = hovered && IsMouseClicked(0, ImGuiInputFlags_None, id);+ const bool double_clicked = (hovered && g.IO.MouseClickedCount[0] == 2 && TestKeyOwner(ImGuiKey_MouseLeft, id)) && !BuiOn(); // BUI: Blender types on a single click (a quick re-press after a drag is a new drag)+ const bool make_active = (clicked || double_clicked || g.NavActivateId == id);+ if (make_active && (clicked || double_clicked))+ SetKeyOwner(ImGuiKey_MouseLeft, id);+ if (make_active && temp_input_allowed)+ if ((clicked && g.IO.KeyCtrl) || double_clicked || (g.NavActivateId == id && (g.NavActivateFlags & ImGuiActivateFlags_PreferInput)))+ temp_input_is_active = true;++ // (Optional) simple click (without moving) turns Drag into an InputText+ if (g.IO.ConfigDragClickToInputText && temp_input_allowed && !temp_input_is_active && !BuiOn()) // BUI: Blender: always (below)+ if (g.ActiveId == id && hovered && g.IO.MouseReleased[0] && !IsMouseDragPastThreshold(0, g.IO.MouseDragThreshold * DRAG_MOUSE_THRESHOLD_FACTOR))+ {+ g.NavActivateId = id;+ g.NavActivateFlags = ImGuiActivateFlags_PreferInput;+ temp_input_is_active = true;+ }++ // Store initial value (not used by main lib but available as a convenience but some mods e.g. to revert)+ if (make_active)+ memcpy(&g.ActiveIdValueOnActivation, p_data, DataTypeGetInfo(data_type)->Size);++ if (make_active && !temp_input_is_active)+ {+ SetActiveID(id, window);+ SetFocusID(id, window);+ FocusWindow(window);+ g.ActiveIdUsingNavDirMask = (1 << ImGuiDir_Left) | (1 << ImGuiDir_Right);+ }+ }++ // BUI: Blender's mouse interaction (BuiNumberBehavior); keyboard / gamepad stay ImGui's+ bool bui_handled = false, bui_changed = false;+ if (BuiOn() && !temp_input_is_active && !(flags & ImGuiSliderFlags_Logarithmic))+ {+ if (hovered || g.ActiveId == id)+ SetMouseCursor(ImGuiMouseCursor_ResizeEW); // Blender's cursor over number fields+ if (g.ActiveId == id && g.ActiveIdSource == ImGuiInputSource_Mouse)+ {+ bool text_edit = false;+ bui_handled = true;+ bui_changed = BuiNumberBehavior(id, frame_bb, data_type, p_data, v_speed, p_min, p_max, format, flags, false, &text_edit);+ if (bui_changed)+ MarkItemEdited(id);+ if (text_edit && temp_input_allowed)+ {+ g.NavActivateId = id;+ g.NavActivateFlags = ImGuiActivateFlags_PreferInput;+ temp_input_is_active = true;+ }+ }+ }++ if (temp_input_is_active)+ {+ const bool clamp_enabled = TempInputIsClampEnabled(flags, data_type, p_min, p_max);+ return TempInputScalar(frame_bb, id, label, data_type, p_data, format, clamp_enabled ? p_min : NULL, clamp_enabled ? p_max : NULL) || bui_changed; // BUI: || bui_changed+ }++ if (BuiOn()) // BUI: Blender number field (number_draw: wcol_num, step arrows on hover)+ {+ const bool value_changed = bui_handled ? bui_changed : DragBehavior(id, data_type, p_data, v_speed, p_min, p_max, format, flags);+ if (value_changed && !bui_handled)+ MarkItemEdited(id);+ RenderNavCursor(frame_bb, id);+ int st = 0;+ if (g.ActiveId == id)+ st = BK_WS_HOVER;+ else if (hovered)+ {+ const float aw = ImMin(frame_bb.GetWidth() / 3.0f, (float)(int)(frame_bb.GetHeight() * 0.7f));+ const float mx = g.IO.MousePos.x;+ st = BK_WS_HOVER | (mx < frame_bb.Min.x + aw ? BK_WS_HOVER_LEFT : mx >= frame_bb.Max.x - aw ? BK_WS_HOVER_RIGHT : 0);+ }+ const bool is_mixed = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;+ char value_buf[64];+ const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_COUNTOF(value_buf), data_type, p_data, (is_mixed && g.MixedValueLabel != NULL) ? g.MixedValueLabel : format);+ if (g.LogEnabled)+ LogRenderedText(&frame_bb.Min, value_buf, value_buf_end);+ BuiNumberEmit(BK_WIDGET_NUMBER, frame_bb, st, value_buf, value_buf_end, 0.0f);+ if (color_marker != 0 && style.ColorMarkerSize > 0.0f)+ RenderColorComponentMarker(frame_bb, GetColorU32(color_marker), style.FrameRounding);+ if (label_size.x > 0.0f)+ RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label, label_end, false);+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | (temp_input_allowed ? ImGuiItemStatusFlags_Inputable : 0));+ return value_changed;+ }++ // Draw frame+ const ImU32 frame_col = GetColorU32(g.ActiveId == id ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);+ RenderNavCursor(frame_bb, id);+ RenderFrame(frame_bb.Min, frame_bb.Max, frame_col, false, style.FrameRounding);+ if (color_marker != 0 && style.ColorMarkerSize > 0.0f)+ RenderColorComponentMarker(frame_bb, GetColorU32(color_marker), style.FrameRounding);+ RenderFrameBorder(frame_bb.Min, frame_bb.Max, g.Style.FrameRounding);++ // Drag behavior+ const bool value_changed = DragBehavior(id, data_type, p_data, v_speed, p_min, p_max, format, flags);+ if (value_changed)+ MarkItemEdited(id);++ // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.+ const bool is_mixed = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;+ char value_buf[64];+ const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_COUNTOF(value_buf), data_type, p_data, (is_mixed && g.MixedValueLabel != NULL) ? g.MixedValueLabel : format);+ if (g.LogEnabled)+ LogSetNextTextDecoration("{", "}");+ if (is_mixed)+ PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextMixedValue]);+ RenderTextClipped(frame_bb.Min, frame_bb.Max, value_buf, value_buf_end, NULL, ImVec2(0.5f, 0.5f));+ if (is_mixed)+ PopStyleColor();++ if (label_size.x > 0.0f)+ RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label, label_end, false);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | (temp_input_allowed ? ImGuiItemStatusFlags_Inputable : 0));+ return value_changed;+}++bool ImGui::DragScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ bool value_changed = false;+ BeginGroup();+ PushID(label);+ const float bui_spacing = BuiAlignBegin(components); // BUI: an aligned row, as Blender's vectors+ PushMultiItemsWidths(components, CalcItemWidth());+ BuiAlignWidths(bui_spacing);+ size_t type_size = GDataTypeInfo[data_type].Size;+ for (int i = 0; i < components; i++)+ {+ PushID(i);+ if (i > 0)+ SameLine(0, BuiOn() ? 0.0f : g.Style.ItemInnerSpacing.x); // BUI+ BuiAlignItem(i, components); // BUI+ if (flags & ImGuiSliderFlags_ColorMarkers)+ SetNextItemColorMarker(GDefaultRgbaColorMarkers[i]);+ value_changed |= DragScalar("", data_type, p_data, v_speed, p_min, p_max, format, flags);+ PopID();+ PopItemWidth();+ p_data = (void*)((char*)p_data + type_size);+ }+ BuiAlignEnd(); // BUI+ PopID();++ const char* label_end = FindRenderedTextEnd(label);+ if (label != label_end)+ {+ SameLine(0, g.Style.ItemInnerSpacing.x);+ TextEx(label, label_end);+ }++ EndGroup();+ return value_changed;+}++bool ImGui::DragFloat(const char* label, float* v, float v_speed, float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, format, flags);+}++bool ImGui::DragFloat2(const char* label, float v[2], float v_speed, float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalarN(label, ImGuiDataType_Float, v, 2, v_speed, &v_min, &v_max, format, flags);+}++bool ImGui::DragFloat3(const char* label, float v[3], float v_speed, float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalarN(label, ImGuiDataType_Float, v, 3, v_speed, &v_min, &v_max, format, flags);+}++bool ImGui::DragFloat4(const char* label, float v[4], float v_speed, float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalarN(label, ImGuiDataType_Float, v, 4, v_speed, &v_min, &v_max, format, flags);+}++// NB: You likely want to specify the ImGuiSliderFlags_AlwaysClamp when using this.+bool ImGui::DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, const char* format, const char* format_max, ImGuiSliderFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ PushID(label);+ BeginGroup();+ const float bui_spacing = BuiAlignBegin(2); // BUI: aligned pair+ PushMultiItemsWidths(2, CalcItemWidth());+ BuiAlignWidths(bui_spacing); // BUI++ float min_min = (v_min >= v_max) ? -FLT_MAX : v_min;+ float min_max = (v_min >= v_max) ? *v_current_max : ImMin(v_max, *v_current_max);+ ImGuiSliderFlags min_flags = flags | ((min_min == min_max) ? ImGuiSliderFlags_ReadOnly : 0);+ BuiAlignItem(0, 2); // BUI+ bool value_changed = DragScalar("##min", ImGuiDataType_Float, v_current_min, v_speed, &min_min, &min_max, format, min_flags);+ PopItemWidth();+ SameLine(0, BuiOn() ? 0.0f : g.Style.ItemInnerSpacing.x); // BUI++ float max_min = (v_min >= v_max) ? *v_current_min : ImMax(v_min, *v_current_min);+ float max_max = (v_min >= v_max) ? FLT_MAX : v_max;+ ImGuiSliderFlags max_flags = flags | ((max_min == max_max) ? ImGuiSliderFlags_ReadOnly : 0);+ BuiAlignItem(1, 2); // BUI+ value_changed |= DragScalar("##max", ImGuiDataType_Float, v_current_max, v_speed, &max_min, &max_max, format_max ? format_max : format, max_flags);+ PopItemWidth();+ SameLine(0, g.Style.ItemInnerSpacing.x);++ BuiAlignEnd(); // BUI+ TextEx(label, FindRenderedTextEnd(label));+ EndGroup();+ PopID();++ return value_changed;+}++// NB: v_speed is float to allow adjusting the drag speed with more precision+bool ImGui::DragInt(const char* label, int* v, float v_speed, int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalar(label, ImGuiDataType_S32, v, v_speed, &v_min, &v_max, format, flags);+}++bool ImGui::DragInt2(const char* label, int v[2], float v_speed, int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalarN(label, ImGuiDataType_S32, v, 2, v_speed, &v_min, &v_max, format, flags);+}++bool ImGui::DragInt3(const char* label, int v[3], float v_speed, int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalarN(label, ImGuiDataType_S32, v, 3, v_speed, &v_min, &v_max, format, flags);+}++bool ImGui::DragInt4(const char* label, int v[4], float v_speed, int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return DragScalarN(label, ImGuiDataType_S32, v, 4, v_speed, &v_min, &v_max, format, flags);+}++// NB: You likely want to specify the ImGuiSliderFlags_AlwaysClamp when using this.+bool ImGui::DragIntRange2(const char* label, int* v_current_min, int* v_current_max, float v_speed, int v_min, int v_max, const char* format, const char* format_max, ImGuiSliderFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ PushID(label);+ BeginGroup();+ const float bui_spacing = BuiAlignBegin(2); // BUI: aligned pair+ PushMultiItemsWidths(2, CalcItemWidth());+ BuiAlignWidths(bui_spacing); // BUI++ int min_min = (v_min >= v_max) ? INT_MIN : v_min;+ int min_max = (v_min >= v_max) ? *v_current_max : ImMin(v_max, *v_current_max);+ ImGuiSliderFlags min_flags = flags | ((min_min == min_max) ? ImGuiSliderFlags_ReadOnly : 0);+ BuiAlignItem(0, 2); // BUI+ bool value_changed = DragInt("##min", v_current_min, v_speed, min_min, min_max, format, min_flags);+ PopItemWidth();+ SameLine(0, BuiOn() ? 0.0f : g.Style.ItemInnerSpacing.x); // BUI++ int max_min = (v_min >= v_max) ? *v_current_min : ImMax(v_min, *v_current_min);+ int max_max = (v_min >= v_max) ? INT_MAX : v_max;+ ImGuiSliderFlags max_flags = flags | ((max_min == max_max) ? ImGuiSliderFlags_ReadOnly : 0);+ BuiAlignItem(1, 2); // BUI+ value_changed |= DragInt("##max", v_current_max, v_speed, max_min, max_max, format_max ? format_max : format, max_flags);+ PopItemWidth();+ SameLine(0, g.Style.ItemInnerSpacing.x);++ BuiAlignEnd(); // BUI+ TextEx(label, FindRenderedTextEnd(label));+ EndGroup();+ PopID();++ return value_changed;+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: SliderScalar, SliderFloat, SliderInt, etc.+//-------------------------------------------------------------------------+// - ScaleRatioFromValueT<> [Internal]+// - ScaleValueFromRatioT<> [Internal]+// - SliderBehaviorT<>() [Internal]+// - SliderBehavior() [Internal]+// - SliderScalar()+// - SliderScalarN()+// - SliderFloat()+// - SliderFloat2()+// - SliderFloat3()+// - SliderFloat4()+// - SliderAngle()+// - SliderInt()+// - SliderInt2()+// - SliderInt3()+// - SliderInt4()+// - VSliderScalar()+// - VSliderFloat()+// - VSliderInt()+//-------------------------------------------------------------------------++// Convert a value v in the output space of a slider into a parametric position on the slider itself (the logical opposite of ScaleValueFromRatioT)+template<typename TYPE, typename SIGNEDTYPE, typename FLOATTYPE>+float ImGui::ScaleRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)+{+ if (v_min == v_max)+ return 0.0f;+ IM_UNUSED(data_type);++ const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ImClamp(v, v_max, v_min);+ if (logarithmic_zero_epsilon > 0.0f) // == is_logarithmic from caller+ {+ bool flipped = v_max < v_min;++ if (flipped) // Handle the case where the range is backwards+ ImSwap(v_min, v_max);++ // Fudge min/max to avoid getting close to log(0)+ FLOATTYPE v_min_fudged = (ImAbs((FLOATTYPE)v_min) < logarithmic_zero_epsilon) ? ((v_min < 0.0f) ? -logarithmic_zero_epsilon : logarithmic_zero_epsilon) : (FLOATTYPE)v_min;+ FLOATTYPE v_max_fudged = (ImAbs((FLOATTYPE)v_max) < logarithmic_zero_epsilon) ? ((v_max < 0.0f) ? -logarithmic_zero_epsilon : logarithmic_zero_epsilon) : (FLOATTYPE)v_max;++ // Awkward special cases - we need ranges of the form (-100 .. 0) to convert to (-100 .. -epsilon), not (-100 .. epsilon)+ if ((v_min == 0.0f) && (v_max < 0.0f))+ v_min_fudged = -logarithmic_zero_epsilon;+ else if ((v_max == 0.0f) && (v_min < 0.0f))+ v_max_fudged = -logarithmic_zero_epsilon;++ float result;+ if (v_clamped <= v_min_fudged)+ result = 0.0f; // Workaround for values that are in-range but below our fudge+ else if (v_clamped >= v_max_fudged)+ result = 1.0f; // Workaround for values that are in-range but above our fudge+ else if (((FLOATTYPE)v_min * (FLOATTYPE)v_max) < 0.0f) // Range crosses zero, so split into two portions+ {+ float zero_point_center = (-(float)v_min) / ((float)v_max - (float)v_min); // The zero point in parametric space. There's an argument we should take the logarithmic nature into account when calculating this, but for now this should do (and the most common case of a symmetrical range works fine)+ float zero_point_snap_L = zero_point_center - zero_deadzone_halfsize;+ float zero_point_snap_R = zero_point_center + zero_deadzone_halfsize;+ if (v == 0.0f)+ result = zero_point_center; // Special case for exactly zero+ else if (v < 0.0f)+ result = (1.0f - (float)(ImLog(-(FLOATTYPE)v_clamped / logarithmic_zero_epsilon) / ImLog(-v_min_fudged / logarithmic_zero_epsilon))) * zero_point_snap_L;+ else+ result = zero_point_snap_R + ((float)(ImLog((FLOATTYPE)v_clamped / logarithmic_zero_epsilon) / ImLog(v_max_fudged / logarithmic_zero_epsilon)) * (1.0f - zero_point_snap_R));+ }+ else if ((v_min < 0.0f) || (v_max < 0.0f)) // Entirely negative slider+ result = 1.0f - (float)(ImLog(-(FLOATTYPE)v_clamped / -v_max_fudged) / ImLog(-v_min_fudged / -v_max_fudged));+ else+ result = (float)(ImLog((FLOATTYPE)v_clamped / v_min_fudged) / ImLog(v_max_fudged / v_min_fudged));++ return flipped ? (1.0f - result) : result;+ }+ else+ {+ // Linear slider+ return (float)((FLOATTYPE)(SIGNEDTYPE)(v_clamped - v_min) / (FLOATTYPE)(SIGNEDTYPE)(v_max - v_min));+ }+}++// Convert a parametric position on a slider into a value v in the output space (the logical opposite of ScaleRatioFromValueT)+template<typename TYPE, typename SIGNEDTYPE, typename FLOATTYPE>+TYPE ImGui::ScaleValueFromRatioT(ImGuiDataType data_type, float t, TYPE v_min, TYPE v_max, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)+{+ // We special-case the extents because otherwise our logarithmic fudging can lead to "mathematically correct"+ // but non-intuitive behaviors like a fully-left slider not actually reaching the minimum value. Also generally simpler.+ if (t <= 0.0f || v_min == v_max)+ return v_min;+ if (t >= 1.0f)+ return v_max;++ TYPE result = (TYPE)0;+ if (logarithmic_zero_epsilon > 0.0f) // == is_logarithmic from caller+ {+ // Fudge min/max to avoid getting silly results close to zero+ FLOATTYPE v_min_fudged = (ImAbs((FLOATTYPE)v_min) < logarithmic_zero_epsilon) ? ((v_min < 0.0f) ? -logarithmic_zero_epsilon : logarithmic_zero_epsilon) : (FLOATTYPE)v_min;+ FLOATTYPE v_max_fudged = (ImAbs((FLOATTYPE)v_max) < logarithmic_zero_epsilon) ? ((v_max < 0.0f) ? -logarithmic_zero_epsilon : logarithmic_zero_epsilon) : (FLOATTYPE)v_max;++ const bool flipped = v_max < v_min; // Check if range is "backwards"+ if (flipped)+ ImSwap(v_min_fudged, v_max_fudged);++ // Awkward special case - we need ranges of the form (-100 .. 0) to convert to (-100 .. -epsilon), not (-100 .. epsilon)+ if ((v_max == 0.0f) && (v_min < 0.0f))+ v_max_fudged = -logarithmic_zero_epsilon;++ float t_with_flip = flipped ? (1.0f - t) : t; // t, but flipped if necessary to account for us flipping the range++ if (((FLOATTYPE)v_min * (FLOATTYPE)v_max) < 0.0f) // Range crosses zero, so we have to do this in two parts+ {+ float zero_point_center = (-(float)ImMin(v_min, v_max)) / ImAbs((float)v_max - (float)v_min); // The zero point in parametric space+ float zero_point_snap_L = zero_point_center - zero_deadzone_halfsize;+ float zero_point_snap_R = zero_point_center + zero_deadzone_halfsize;+ if (t_with_flip >= zero_point_snap_L && t_with_flip <= zero_point_snap_R)+ result = (TYPE)0.0f; // Special case to make getting exactly zero possible (the epsilon prevents it otherwise)+ else if (t_with_flip < zero_point_center)+ result = (TYPE)-(logarithmic_zero_epsilon * ImPow(-v_min_fudged / logarithmic_zero_epsilon, (FLOATTYPE)(1.0f - (t_with_flip / zero_point_snap_L))));+ else+ result = (TYPE)(logarithmic_zero_epsilon * ImPow(v_max_fudged / logarithmic_zero_epsilon, (FLOATTYPE)((t_with_flip - zero_point_snap_R) / (1.0f - zero_point_snap_R))));+ }+ else if ((v_min < 0.0f) || (v_max < 0.0f)) // Entirely negative slider+ result = (TYPE)-(-v_max_fudged * ImPow(-v_min_fudged / -v_max_fudged, (FLOATTYPE)(1.0f - t_with_flip)));+ else+ result = (TYPE)(v_min_fudged * ImPow(v_max_fudged / v_min_fudged, (FLOATTYPE)t_with_flip));+ }+ else+ {+ // Linear slider+ const bool is_floating_point = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);+ if (is_floating_point)+ {+ result = ImLerp(v_min, v_max, t);+ }+ else // t is already < 1.0 here+ {+ // - For integer values we want the clicking position to match the grab box so we round above+ // This code is carefully tuned to work with large values (e.g. high ranges of U64) while preserving this property..+ // - Not doing a *1.0 multiply at the end of a range as it tends to be lossy. While absolute aiming at a large s64/u64+ // range is going to be imprecise anyway, with this check we at least make the edge values matches expected limits.+ FLOATTYPE v_new_off_f = (FLOATTYPE)(SIGNEDTYPE)(v_max - v_min) * (FLOATTYPE)t;+ result = (TYPE)((SIGNEDTYPE)v_min + (SIGNEDTYPE)(v_new_off_f + (FLOATTYPE)(v_min > v_max ? -0.5 : 0.5)));+ }+ }++ return result;+}++// FIXME: Try to move more of the code into shared SliderBehavior()+template<typename TYPE, typename SIGNEDTYPE, typename FLOATTYPE>+bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)+{+ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;++ const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;+ const bool is_logarithmic = (flags & ImGuiSliderFlags_Logarithmic) != 0;+ const bool is_floating_point = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);+ const float v_range_f = (float)(v_min < v_max ? v_max - v_min : v_min - v_max); // We don't need high precision for what we do with it.++ // Calculate bounds+ const float grab_padding = 2.0f; // FIXME: Should be part of style.+ const float slider_sz = (bb.Max[axis] - bb.Min[axis]) - grab_padding * 2.0f;+ float grab_sz = style.GrabMinSize;+ if (!is_floating_point && v_range_f >= 0.0f) // v_range_f < 0 may happen on integer overflows+ grab_sz = ImMax(slider_sz / (v_range_f + 1), style.GrabMinSize); // For integer sliders: if possible have the grab size represent 1 unit+ grab_sz = ImMin(grab_sz, slider_sz);+ const float slider_usable_sz = slider_sz - grab_sz;+ const float slider_usable_pos_min = bb.Min[axis] + grab_padding + grab_sz * 0.5f;+ const float slider_usable_pos_max = bb.Max[axis] - grab_padding - grab_sz * 0.5f;++ float logarithmic_zero_epsilon = 0.0f; // Only valid when is_logarithmic is true+ float zero_deadzone_halfsize = 0.0f; // Only valid when is_logarithmic is true+ if (is_logarithmic)+ {+ // When using logarithmic sliders, we need to clamp to avoid hitting zero, but our choice of clamp value greatly affects slider precision. We attempt to use the specified precision to estimate a good lower bound.+ const int decimal_precision = is_floating_point ? ImParseFormatPrecision(format, 3) : 1;+ logarithmic_zero_epsilon = ImPow(0.1f, (float)decimal_precision);+ zero_deadzone_halfsize = (style.LogSliderDeadzone * 0.5f) / ImMax(slider_usable_sz, 1.0f);+ }++ // Process interacting with the slider+ bool value_changed = false;+ if (g.ActiveId == id)+ {+ bool set_new_value = false;+ float clicked_t = 0.0f;+ if (g.ActiveIdSource == ImGuiInputSource_Mouse)+ {+ const float mouse_pos = g.IO.MousePos[axis];+ if (g.ActiveIdIsJustActivated)+ {+ float grab_t = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, *v, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);+ if (axis == ImGuiAxis_Y)+ grab_t = 1.0f - grab_t;+ const float grab_pos = ImLerp(slider_usable_pos_min, slider_usable_pos_max, grab_t);+ const bool clicked_around_grab = (mouse_pos >= grab_pos - grab_sz * 0.5f - 1.0f) && (mouse_pos <= grab_pos + grab_sz * 0.5f + 1.0f); // No harm being extra generous here.+ g.SliderGrabClickOffset = (clicked_around_grab && is_floating_point) ? mouse_pos - grab_pos : 0.0f;+ }+ if (slider_usable_sz > 0.0f)+ clicked_t = ImSaturate((mouse_pos - g.SliderGrabClickOffset - slider_usable_pos_min) / slider_usable_sz);+ if (axis == ImGuiAxis_Y)+ clicked_t = 1.0f - clicked_t;+ set_new_value = true;+ }+ else if (g.ActiveIdSource == ImGuiInputSource_Keyboard || g.ActiveIdSource == ImGuiInputSource_Gamepad)+ {+ float input_delta = (axis == ImGuiAxis_X) ? GetNavTweakPressedAmount(axis) : -GetNavTweakPressedAmount(axis);+ if (input_delta != 0.0f)+ {+ const bool tweak_slow = IsKeyDown((g.NavInputSource == ImGuiInputSource_Gamepad) ? ImGuiKey_NavGamepadTweakSlow : ImGuiKey_NavKeyboardTweakSlow);+ const bool tweak_fast = IsKeyDown((g.NavInputSource == ImGuiInputSource_Gamepad) ? ImGuiKey_NavGamepadTweakFast : ImGuiKey_NavKeyboardTweakFast);+ const int decimal_precision = is_floating_point ? ImParseFormatPrecision(format, 3) : 0;+ if (decimal_precision > 0)+ {+ input_delta /= 100.0f; // Keyboard/Gamepad tweak speeds in % of slider bounds+ if (tweak_slow)+ input_delta /= 10.0f;+ }+ else+ {+ if ((v_range_f >= -100.0f && v_range_f <= 100.0f && v_range_f != 0.0f) || tweak_slow)+ input_delta = ((input_delta < 0.0f) ? -1.0f : +1.0f) / v_range_f; // Keyboard/Gamepad tweak speeds in integer steps+ else+ input_delta /= 100.0f;+ }+ if (tweak_fast)+ input_delta *= 10.0f;++ g.SliderCurrentAccum += input_delta;+ g.SliderCurrentAccumDirty = true;+ }++ float delta = g.SliderCurrentAccum;+ if (g.SliderCurrentAccumDirty)+ {+ clicked_t = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, *v, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);++ if ((clicked_t >= 1.0f && delta > 0.0f) || (clicked_t <= 0.0f && delta < 0.0f)) // This is to avoid applying the saturation when already past the limits+ {+ set_new_value = false;+ g.SliderCurrentAccum = 0.0f; // If pushing up against the limits, don't continue to accumulate+ }+ else+ {+ set_new_value = true;+ float old_clicked_t = clicked_t;+ clicked_t = ImSaturate(clicked_t + delta);++ // Calculate what our "new" clicked_t will be, and thus how far we actually moved the slider, and subtract this from the accumulator+ TYPE v_new = ScaleValueFromRatioT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, clicked_t, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);+ if (is_floating_point && !(flags & ImGuiSliderFlags_NoRoundToFormat))+ v_new = RoundScalarWithFormatT<TYPE>(format, data_type, v_new);+ float new_clicked_t = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_new, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);++ if (delta > 0)+ g.SliderCurrentAccum -= ImMin(new_clicked_t - old_clicked_t, delta);+ else+ g.SliderCurrentAccum -= ImMax(new_clicked_t - old_clicked_t, delta);+ }+ g.SliderCurrentAccumDirty = false;+ }+ }++ if (set_new_value)+ if ((g.LastItemData.ItemFlags & ImGuiItemFlags_ReadOnly) || (flags & ImGuiSliderFlags_ReadOnly))+ set_new_value = false;++ if (set_new_value)+ {+ TYPE v_new = ScaleValueFromRatioT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, clicked_t, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);++ // Round to user desired precision based on format string+ if (is_floating_point && !(flags & ImGuiSliderFlags_NoRoundToFormat))+ v_new = RoundScalarWithFormatT<TYPE>(format, data_type, v_new);++ // Apply result+ if (*v != v_new)+ {+ *v = v_new;+ value_changed = true;+ }+ }+ }++ if (slider_sz < 1.0f)+ {+ *out_grab_bb = ImRect(bb.Min, bb.Min);+ }+ else+ {+ // Output grab position so it can be displayed by the caller+ float grab_t = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, *v, v_min, v_max, logarithmic_zero_epsilon, zero_deadzone_halfsize);+ if (axis == ImGuiAxis_Y)+ grab_t = 1.0f - grab_t;+ const float grab_pos = ImLerp(slider_usable_pos_min, slider_usable_pos_max, grab_t);+ if (axis == ImGuiAxis_X)+ *out_grab_bb = ImRect(grab_pos - grab_sz * 0.5f, bb.Min.y + grab_padding, grab_pos + grab_sz * 0.5f, bb.Max.y - grab_padding);+ else+ *out_grab_bb = ImRect(bb.Min.x + grab_padding, grab_pos - grab_sz * 0.5f, bb.Max.x - grab_padding, grab_pos + grab_sz * 0.5f);+ }++ return value_changed;+}++// For 32-bit and larger types, slider bounds are limited to half the natural type range.+// So e.g. an integer Slider between INT_MAX-10 and INT_MAX will fail, but an integer Slider between INT_MAX/2-10 and INT_MAX/2 will be ok.+// It would be possible to lift that limitation with some work but it doesn't seem to be worth it for sliders.+bool ImGui::SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)+{+ // Read imgui.cpp "API BREAKING CHANGES" section for 1.78 if you hit this assert.+ IM_ASSERT((flags == 1 || (flags & ImGuiSliderFlags_InvalidMask_) == 0) && "Invalid ImGuiSliderFlags flags! Has the legacy 'float power' argument been mistakenly cast to flags? Call function with ImGuiSliderFlags_Logarithmic flags instead.");+ IM_ASSERT((flags & ImGuiSliderFlags_WrapAround) == 0); // Not supported by SliderXXX(), only by DragXXX()++ // Things we can do easily outside the SliderBehaviorT<> template, saves code generation.+ ImGuiContext& g = *GImGui;+ if (g.ActiveId == id)+ {+ if (g.ActiveIdSource == ImGuiInputSource_Mouse && !g.IO.MouseDown[0])+ ClearActiveID();+ if (g.ActiveIdSource == ImGuiInputSource_Keyboard || g.ActiveIdSource == ImGuiInputSource_Gamepad)+ {+ if (g.ActiveIdIsJustActivated)+ {+ g.SliderCurrentAccum = 0.0f; // Reset any stored nav delta upon activation+ g.SliderCurrentAccumDirty = false;+ }+ if (g.NavActivatePressedId == id && !g.ActiveIdIsJustActivated)+ ClearActiveID();+ }+ if (ShortcutsForCancel(id) && g.ActiveId == id) //-V560+ {+ // Canceling action reverts to initial value+ size_t data_size = DataTypeGetInfo(data_type)->Size;+ bool value_changed = memcmp(p_v, &g.ActiveIdValueOnActivation, data_size) != 0;+ memcpy(p_v, &g.ActiveIdValueOnActivation, data_size);+ ClearActiveID();+ return value_changed;+ }+ }++ switch (data_type)+ {+ case ImGuiDataType_S8: { ImS32 v32 = (ImS32)*(ImS8*)p_v; bool r = SliderBehaviorT<ImS32, ImS32, float>(bb, id, ImGuiDataType_S32, &v32, *(const ImS8*)p_min, *(const ImS8*)p_max, format, flags, out_grab_bb); if (r) *(ImS8*)p_v = (ImS8)v32; return r; }+ case ImGuiDataType_U8: { ImU32 v32 = (ImU32)*(ImU8*)p_v; bool r = SliderBehaviorT<ImU32, ImS32, float>(bb, id, ImGuiDataType_U32, &v32, *(const ImU8*)p_min, *(const ImU8*)p_max, format, flags, out_grab_bb); if (r) *(ImU8*)p_v = (ImU8)v32; return r; }+ case ImGuiDataType_S16: { ImS32 v32 = (ImS32)*(ImS16*)p_v; bool r = SliderBehaviorT<ImS32, ImS32, float>(bb, id, ImGuiDataType_S32, &v32, *(const ImS16*)p_min, *(const ImS16*)p_max, format, flags, out_grab_bb); if (r) *(ImS16*)p_v = (ImS16)v32; return r; }+ case ImGuiDataType_U16: { ImU32 v32 = (ImU32)*(ImU16*)p_v; bool r = SliderBehaviorT<ImU32, ImS32, float>(bb, id, ImGuiDataType_U32, &v32, *(const ImU16*)p_min, *(const ImU16*)p_max, format, flags, out_grab_bb); if (r) *(ImU16*)p_v = (ImU16)v32; return r; }+ case ImGuiDataType_S32:+ IM_ASSERT(*(const ImS32*)p_min >= IM_S32_MIN / 2 && *(const ImS32*)p_max <= IM_S32_MAX / 2);+ return SliderBehaviorT<ImS32, ImS32, float >(bb, id, data_type, (ImS32*)p_v, *(const ImS32*)p_min, *(const ImS32*)p_max, format, flags, out_grab_bb);+ case ImGuiDataType_U32:+ IM_ASSERT(*(const ImU32*)p_max <= IM_U32_MAX / 2);+ return SliderBehaviorT<ImU32, ImS32, float >(bb, id, data_type, (ImU32*)p_v, *(const ImU32*)p_min, *(const ImU32*)p_max, format, flags, out_grab_bb);+ case ImGuiDataType_S64:+ IM_ASSERT(*(const ImS64*)p_min >= IM_S64_MIN / 2 && *(const ImS64*)p_max <= IM_S64_MAX / 2);+ return SliderBehaviorT<ImS64, ImS64, double>(bb, id, data_type, (ImS64*)p_v, *(const ImS64*)p_min, *(const ImS64*)p_max, format, flags, out_grab_bb);+ case ImGuiDataType_U64:+ IM_ASSERT(*(const ImU64*)p_max <= IM_U64_MAX / 2);+ return SliderBehaviorT<ImU64, ImS64, double>(bb, id, data_type, (ImU64*)p_v, *(const ImU64*)p_min, *(const ImU64*)p_max, format, flags, out_grab_bb);+ case ImGuiDataType_Float:+ IM_ASSERT(*(const float*)p_min >= -FLT_MAX / 2.0f && *(const float*)p_max <= FLT_MAX / 2.0f);+ return SliderBehaviorT<float, float, float >(bb, id, data_type, (float*)p_v, *(const float*)p_min, *(const float*)p_max, format, flags, out_grab_bb);+ case ImGuiDataType_Double:+ IM_ASSERT(*(const double*)p_min >= -DBL_MAX / 2.0f && *(const double*)p_max <= DBL_MAX / 2.0f);+ return SliderBehaviorT<double, double, double>(bb, id, data_type, (double*)p_v, *(const double*)p_min, *(const double*)p_max, format, flags, out_grab_bb);+ case ImGuiDataType_COUNT: break;+ }+ IM_ASSERT(0);+ return false;+}++// Note: p_data, p_min and p_max are _pointers_ to a memory address holding the data. For a slider, they are all required.+// Read code of e.g. SliderFloat(), SliderInt() etc. or examples in 'Demo->Widgets->Data Types' to understand how to use this function directly.+bool ImGui::SliderScalar(const char* label, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);+ const float w = CalcItemWidth();+ const ImU32 color_marker = (g.NextItemData.HasFlags & ImGuiNextItemDataFlags_HasColorMarker) ? g.NextItemData.ColorMarker : 0;++ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);+ const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y * 2.0f));+ const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));++ const bool temp_input_allowed = (flags & ImGuiSliderFlags_NoInput) == 0;+ ItemSize(total_bb, style.FramePadding.y);+ if (!ItemAdd(total_bb, id, &frame_bb, temp_input_allowed ? ImGuiItemFlags_Inputable : 0))+ return false;++ // Default format string when passing NULL+ if (format == NULL)+ format = DataTypeGetInfo(data_type)->PrintFmt;++ const bool hovered = ItemHoverable(frame_bb, id, g.LastItemData.ItemFlags);+ bool temp_input_is_active = temp_input_allowed && TempInputIsActive(id);+ if (!temp_input_is_active)+ {+ // Tabbing or Ctrl+Click on Slider turns it into an input box+ const bool clicked = hovered && IsMouseClicked(0, ImGuiInputFlags_None, id);+ const bool make_active = (clicked || g.NavActivateId == id);+ if (make_active && clicked)+ SetKeyOwner(ImGuiKey_MouseLeft, id);+ if (make_active && temp_input_allowed)+ if ((clicked && g.IO.KeyCtrl) || (g.NavActivateId == id && (g.NavActivateFlags & ImGuiActivateFlags_PreferInput)))+ temp_input_is_active = true;++ // Store initial value (not used by main lib but available as a convenience but some mods e.g. to revert)+ if (make_active)+ memcpy(&g.ActiveIdValueOnActivation, p_data, DataTypeGetInfo(data_type)->Size);++ if (make_active && !temp_input_is_active)+ {+ SetActiveID(id, window);+ SetFocusID(id, window);+ FocusWindow(window);+ g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Left) | (1 << ImGuiDir_Right);+ }+ }++ // BUI: Blender's mouse interaction (BuiNumberBehavior: relative drag, click types); keyboard /+ // gamepad and logarithmic or reversed ranges stay ImGui's+ bool bui_handled = false, bui_changed = false;+ const bool bui_linear = BuiOn() && !(flags & ImGuiSliderFlags_Logarithmic) && BuiGetValue(data_type, p_min) < BuiGetValue(data_type, p_max);+ if (bui_linear && !temp_input_is_active && g.ActiveId == id && g.ActiveIdSource == ImGuiInputSource_Mouse)+ {+ bool text_edit = false;+ bui_handled = true;+ bui_changed = BuiNumberBehavior(id, frame_bb, data_type, p_data, 0.0f, p_min, p_max, format, flags, true, &text_edit);+ if (bui_changed)+ MarkItemEdited(id);+ if (text_edit && temp_input_allowed)+ {+ g.NavActivateId = id;+ g.NavActivateFlags = ImGuiActivateFlags_PreferInput;+ temp_input_is_active = true;+ }+ }++ if (temp_input_is_active)+ {+ // Only clamp Ctrl+Click input when ImGuiSliderFlags_ClampOnInput is set (generally via ImGuiSliderFlags_AlwaysClamp)+ const bool clamp_enabled = (flags & ImGuiSliderFlags_ClampOnInput) != 0; // Don't use TempInputIsClampEnabled()+ return TempInputScalar(frame_bb, id, label, data_type, p_data, format, clamp_enabled ? p_min : NULL, clamp_enabled ? p_max : NULL) || bui_changed; // BUI: || bui_changed+ }++ if (BuiOn()) // BUI: Blender number slider (slider_draw: wcol_numslider, the fill bar, value inside)+ {+ ImRect grab_bb;+ const bool value_changed = bui_handled ? bui_changed : SliderBehavior(frame_bb, id, data_type, p_data, p_min, p_max, format, flags, &grab_bb);+ if (value_changed && !bui_handled)+ MarkItemEdited(id);+ if (hovered || g.ActiveId == id)+ SetMouseCursor(ImGuiMouseCursor_ResizeEW); // Blender's cursor over number sliders+ RenderNavCursor(frame_bb, id);+ float factor;+ if (bui_linear)+ factor = (float)((BuiGetValue(data_type, p_data) - BuiGetValue(data_type, p_min)) / (BuiGetValue(data_type, p_max) - BuiGetValue(data_type, p_min)));+ else if (grab_bb.Max.x > grab_bb.Min.x)+ factor = (grab_bb.GetCenter().x - frame_bb.Min.x) / ImMax(frame_bb.GetWidth(), 1.0f);+ else+ factor = 0.0f;+ const bool is_mixed = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;+ char value_buf[64];+ const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_COUNTOF(value_buf), data_type, p_data, (is_mixed && g.MixedValueLabel != NULL) ? g.MixedValueLabel : format);+ if (g.LogEnabled)+ LogRenderedText(&frame_bb.Min, value_buf, value_buf_end);+ BuiNumberEmit(BK_WIDGET_SLIDER, frame_bb, (hovered || g.ActiveId == id) ? BK_WS_HOVER : 0, value_buf, value_buf_end, ImSaturate(factor));+ if (color_marker != 0 && style.ColorMarkerSize > 0.0f)+ RenderColorComponentMarker(frame_bb, GetColorU32(color_marker), style.FrameRounding);+ if (label_size.x > 0.0f)+ RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label, label_end, false);+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | (temp_input_allowed ? ImGuiItemStatusFlags_Inputable : 0));+ return value_changed;+ }++ // Draw frame+ const ImU32 frame_col = GetColorU32(g.ActiveId == id ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);+ RenderNavCursor(frame_bb, id);+ RenderFrame(frame_bb.Min, frame_bb.Max, frame_col, false, style.FrameRounding);+ if (color_marker != 0 && style.ColorMarkerSize > 0.0f)+ RenderColorComponentMarker(frame_bb, GetColorU32(color_marker), style.FrameRounding);+ RenderFrameBorder(frame_bb.Min, frame_bb.Max, g.Style.FrameRounding);++ // Slider behavior+ ImRect grab_bb;+ const bool value_changed = SliderBehavior(frame_bb, id, data_type, p_data, p_min, p_max, format, flags, &grab_bb);+ if (value_changed)+ MarkItemEdited(id);++ // Render grab+ if (grab_bb.Max.x > grab_bb.Min.x)+ window->DrawList->AddRectFilled(grab_bb.Min, grab_bb.Max, GetColorU32(g.ActiveId == id ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), style.GrabRounding);++ // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.+ const bool is_mixed = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;+ char value_buf[64];+ const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_COUNTOF(value_buf), data_type, p_data, (is_mixed && g.MixedValueLabel != NULL) ? g.MixedValueLabel : format);+ if (g.LogEnabled)+ LogSetNextTextDecoration("{", "}");+ if (is_mixed)+ PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextMixedValue]);+ RenderTextClipped(frame_bb.Min, frame_bb.Max, value_buf, value_buf_end, NULL, ImVec2(0.5f, 0.5f));+ if (is_mixed)+ PopStyleColor();++ if (label_size.x > 0.0f)+ RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label, label_end, false);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | (temp_input_allowed ? ImGuiItemStatusFlags_Inputable : 0));+ return value_changed;+}++// Add multiple sliders on 1 line for compact edition of multiple components+bool ImGui::SliderScalarN(const char* label, ImGuiDataType data_type, void* v, int components, const void* v_min, const void* v_max, const char* format, ImGuiSliderFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ bool value_changed = false;+ BeginGroup();+ PushID(label);+ const float bui_spacing = BuiAlignBegin(components); // BUI: an aligned row+ PushMultiItemsWidths(components, CalcItemWidth());+ BuiAlignWidths(bui_spacing); // BUI+ size_t type_size = GDataTypeInfo[data_type].Size;+ for (int i = 0; i < components; i++)+ {+ PushID(i);+ if (i > 0)+ SameLine(0, BuiOn() ? 0.0f : g.Style.ItemInnerSpacing.x); // BUI+ BuiAlignItem(i, components); // BUI+ if (flags & ImGuiSliderFlags_ColorMarkers)+ SetNextItemColorMarker(GDefaultRgbaColorMarkers[i]);+ value_changed |= SliderScalar("", data_type, v, v_min, v_max, format, flags);+ PopID();+ PopItemWidth();+ v = (void*)((char*)v + type_size);+ }+ BuiAlignEnd(); // BUI+ PopID();++ const char* label_end = FindRenderedTextEnd(label);+ if (label != label_end)+ {+ SameLine(0, g.Style.ItemInnerSpacing.x);+ TextEx(label, label_end);+ }++ EndGroup();+ return value_changed;+}++bool ImGui::SliderFloat(const char* label, float* v, float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalar(label, ImGuiDataType_Float, v, &v_min, &v_max, format, flags);+}++bool ImGui::SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalarN(label, ImGuiDataType_Float, v, 2, &v_min, &v_max, format, flags);+}++bool ImGui::SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalarN(label, ImGuiDataType_Float, v, 3, &v_min, &v_max, format, flags);+}++bool ImGui::SliderFloat4(const char* label, float v[4], float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalarN(label, ImGuiDataType_Float, v, 4, &v_min, &v_max, format, flags);+}++bool ImGui::SliderAngle(const char* label, float* v_rad, float v_degrees_min, float v_degrees_max, const char* format, ImGuiSliderFlags flags)+{+ if (format == NULL)+ format = "%.0f deg";+ float v_deg = (*v_rad) * 360.0f / (2 * IM_PI);+ bool value_changed = SliderFloat(label, &v_deg, v_degrees_min, v_degrees_max, format, flags);+ if (value_changed)+ *v_rad = v_deg * (2 * IM_PI) / 360.0f;+ return value_changed;+}++bool ImGui::SliderInt(const char* label, int* v, int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalar(label, ImGuiDataType_S32, v, &v_min, &v_max, format, flags);+}++bool ImGui::SliderInt2(const char* label, int v[2], int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalarN(label, ImGuiDataType_S32, v, 2, &v_min, &v_max, format, flags);+}++bool ImGui::SliderInt3(const char* label, int v[3], int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalarN(label, ImGuiDataType_S32, v, 3, &v_min, &v_max, format, flags);+}++bool ImGui::SliderInt4(const char* label, int v[4], int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return SliderScalarN(label, ImGuiDataType_S32, v, 4, &v_min, &v_max, format, flags);+}++bool ImGui::VSliderScalar(const char* label, const ImVec2& size, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);++ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);+ const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + size);+ const ImRect bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));++ ItemSize(bb, style.FramePadding.y);+ if (!ItemAdd(frame_bb, id))+ return false;++ // Default format string when passing NULL+ if (format == NULL)+ format = DataTypeGetInfo(data_type)->PrintFmt;++ const bool hovered = ItemHoverable(frame_bb, id, g.LastItemData.ItemFlags);+ const bool clicked = hovered && IsMouseClicked(0, ImGuiInputFlags_None, id);+ if (clicked || g.NavActivateId == id)+ {+ if (clicked)+ SetKeyOwner(ImGuiKey_MouseLeft, id);+ SetActiveID(id, window);+ SetFocusID(id, window);+ FocusWindow(window);+ g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Up) | (1 << ImGuiDir_Down);+ }++ // Draw frame+ const ImU32 frame_col = GetColorU32(g.ActiveId == id ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);+ RenderNavCursor(frame_bb, id);+ RenderFrame(frame_bb.Min, frame_bb.Max, frame_col, true, g.Style.FrameRounding);++ // Slider behavior+ ImRect grab_bb;+ const bool value_changed = SliderBehavior(frame_bb, id, data_type, p_data, p_min, p_max, format, flags | ImGuiSliderFlags_Vertical, &grab_bb);+ if (value_changed)+ MarkItemEdited(id);++ // Render grab+ if (grab_bb.Max.y > grab_bb.Min.y)+ window->DrawList->AddRectFilled(grab_bb.Min, grab_bb.Max, GetColorU32(g.ActiveId == id ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), style.GrabRounding);++ // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.+ // For the vertical slider we allow centered text to overlap the frame padding+ const bool is_mixed = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;+ char value_buf[64];+ const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_COUNTOF(value_buf), data_type, p_data, (is_mixed && g.MixedValueLabel != NULL) ? g.MixedValueLabel : format);+ if (is_mixed)+ PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextMixedValue]);+ RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, value_buf, value_buf_end, NULL, ImVec2(0.5f, 0.0f));+ if (is_mixed)+ PopStyleColor();++ if (label_size.x > 0.0f)+ RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label, label_end, false);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return value_changed;+}++bool ImGui::VSliderFloat(const char* label, const ImVec2& size, float* v, float v_min, float v_max, const char* format, ImGuiSliderFlags flags)+{+ return VSliderScalar(label, size, ImGuiDataType_Float, v, &v_min, &v_max, format, flags);+}++bool ImGui::VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* format, ImGuiSliderFlags flags)+{+ return VSliderScalar(label, size, ImGuiDataType_S32, v, &v_min, &v_max, format, flags);+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: InputScalar, InputFloat, InputInt, etc.+//-------------------------------------------------------------------------+// - ImParseFormatFindStart() [Internal]+// - ImParseFormatFindEnd() [Internal]+// - ImParseFormatTrimDecorations() [Internal]+// - ImParseFormatSanitizeForPrinting() [Internal]+// - ImParseFormatSanitizeForScanning() [Internal]+// - ImParseFormatPrecision() [Internal]+// - TempInputText() [Internal]+// - TempInputScalar() [Internal]+// - InputScalar()+// - InputScalarN()+// - InputFloat()+// - InputFloat2()+// - InputFloat3()+// - InputFloat4()+// - InputInt()+// - InputInt2()+// - InputInt3()+// - InputInt4()+// - InputDouble()+//-------------------------------------------------------------------------++// We don't use strchr() because our strings are usually very short and often start with '%'+const char* ImParseFormatFindStart(const char* fmt)+{+ while (char c = fmt[0])+ {+ if (c == '%' && fmt[1] != '%')+ return fmt;+ else if (c == '%')+ fmt++;+ fmt++;+ }+ return fmt;+}++const char* ImParseFormatFindEnd(const char* fmt)+{+ // Printf/scanf types modifiers: I/L/h/j/l/t/w/z. Other uppercase letters qualify as types aka end of the format.+ if (fmt[0] != '%')+ return fmt;+ const unsigned int ignored_uppercase_mask = (1 << ('I'-'A')) | (1 << ('L'-'A'));+ const unsigned int ignored_lowercase_mask = (1 << ('h'-'a')) | (1 << ('j'-'a')) | (1 << ('l'-'a')) | (1 << ('t'-'a')) | (1 << ('w'-'a')) | (1 << ('z'-'a'));+ for (char c; (c = *fmt) != 0; fmt++)+ {+ if (c >= 'A' && c <= 'Z' && ((1 << (c - 'A')) & ignored_uppercase_mask) == 0)+ return fmt + 1;+ if (c >= 'a' && c <= 'z' && ((1 << (c - 'a')) & ignored_lowercase_mask) == 0)+ return fmt + 1;+ }+ return fmt;+}++// Extract the format out of a format string with leading or trailing decorations+// fmt = "blah blah" -> return ""+// fmt = "%.3f" -> return fmt+// fmt = "hello %.3f" -> return fmt + 6+// fmt = "%.3f hello" -> return buf written with "%.3f"+const char* ImParseFormatTrimDecorations(const char* fmt, char* buf, size_t buf_size)+{+ const char* fmt_start = ImParseFormatFindStart(fmt);+ if (fmt_start[0] != '%')+ return "";+ const char* fmt_end = ImParseFormatFindEnd(fmt_start);+ if (fmt_end[0] == 0) // If we only have leading decoration, we don't need to copy the data.+ return fmt_start;+ buf[0] = 0; // Fix false positive with caller assuming that buf could be non-initialized (#9508)+ ImStrncpy(buf, fmt_start, ImMin((size_t)(fmt_end - fmt_start) + 1, buf_size));+ return buf;+}++// Sanitize format+// - Zero terminate so extra characters after format (e.g. "%f123") don't confuse atof/atoi+// - stb_sprintf.h supports several new modifiers which format numbers in a way that also makes them incompatible atof/atoi.+void ImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size)+{+ const char* fmt_end = ImParseFormatFindEnd(fmt_in);+ IM_UNUSED(fmt_out_size);+ IM_ASSERT((size_t)(fmt_end - fmt_in + 1) < fmt_out_size); // Format is too long, let us know if this happens to you!+ while (fmt_in < fmt_end)+ {+ char c = *fmt_in++;+ if (c != '\'' && c != '$' && c != '_') // Custom flags provided by stb_sprintf.h. POSIX 2008 also supports '.+ *(fmt_out++) = c;+ }+ *fmt_out = 0; // Zero-terminate+}++// - For scanning we need to remove all width and precision fields and flags "%+3.7f" -> "%f". BUT don't strip types like "%I64d" which includes digits. ! "%07I64d" -> "%I64d"+const char* ImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size)+{+ const char* fmt_end = ImParseFormatFindEnd(fmt_in);+ const char* fmt_out_begin = fmt_out;+ IM_UNUSED(fmt_out_size);+ IM_ASSERT((size_t)(fmt_end - fmt_in + 1) < fmt_out_size); // Format is too long, let us know if this happens to you!+ bool has_type = false;+ while (fmt_in < fmt_end)+ {+ char c = *fmt_in++;+ if (!has_type && ((c >= '0' && c <= '9') || c == '.' || c == '+' || c == '#'))+ continue;+ has_type |= ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); // Stop skipping digits+ if (c != '\'' && c != '$' && c != '_') // Custom flags provided by stb_sprintf.h. POSIX 2008 also supports '.+ *(fmt_out++) = c;+ }+ *fmt_out = 0; // Zero-terminate+ return fmt_out_begin;+}++template<typename TYPE>+static const char* ImAtoi(const char* src, TYPE* output)+{+ int negative = 0;+ if (*src == '-') { negative = 1; src++; }+ if (*src == '+') { src++; }+ TYPE v = 0;+ while (*src >= '0' && *src <= '9')+ v = (v * 10) + (*src++ - '0');+ *output = negative ? -v : v;+ return src;+}++// Parse display precision back from the display format string+// FIXME: This is still used by some navigation code path to infer a minimum tweak step, but we should aim to rework widgets so it isn't needed.+int ImParseFormatPrecision(const char* fmt, int default_precision)+{+ fmt = ImParseFormatFindStart(fmt);+ if (fmt[0] != '%')+ return default_precision;+ fmt++;+ while (*fmt >= '0' && *fmt <= '9')+ fmt++;+ int precision = INT_MAX;+ if (*fmt == '.')+ {+ fmt = ImAtoi<int>(fmt + 1, &precision);+ if (precision < 0 || precision > 99)+ precision = default_precision;+ }+ if (*fmt == 'e' || *fmt == 'E') // Maximum precision with scientific notation+ precision = -1;+ if ((*fmt == 'g' || *fmt == 'G') && precision == INT_MAX)+ precision = -1;+ return (precision == INT_MAX) ? default_precision : precision;+}++// Create text input in place of another active widget (e.g. used when doing a Ctrl+Click on drag/slider widgets)+// - This must be submitted right after the item it is overlaying.+// FIXME: Facilitate using this in variety of other situations.+bool ImGui::TempInputText(const ImRect& bb, ImGuiID id, const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)+{+ // On the first frame, g.TempInputTextId == 0, then on subsequent frames it becomes == id.+ // We clear ActiveID on the first frame to allow the InputText() taking it back.+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ const bool is_deactivated = (g.InputTextDeactivatedState.ID == id);+ const bool is_active = (g.TempInputId == id);+ if (!is_active && !is_deactivated)+ ClearActiveID();++ ImVec2 backup_pos = window->DC.CursorPos;+ window->DC.CursorPos = bb.Min;+ g.LastItemData.ItemFlags |= ImGuiItemFlags_AllowDuplicateId; // Using ImGuiInputTextFlags_MergedItem above will skip ItemAdd() so we poke here.+ bool value_changed = InputTextEx(label, NULL, buf, (int)buf_size, bb.GetSize(), flags | ImGuiInputTextFlags_TempInput | ImGuiInputTextFlags_AutoSelectAll, callback, user_data);+ KeepAliveID(id); // Not done because of ImGuiInputTextFlags_TempInput+ if (!is_active && !is_deactivated)+ {+ // First frame we started displaying the InputText widget, we expect it to take the active id.+ IM_ASSERT(g.ActiveId == id);+ g.TempInputId = g.ActiveId;+ }+ if (is_active && g.ActiveId != id)+ g.TempInputId = 0;+ window->DC.CursorPos = backup_pos;+ return value_changed;+}++// Note that Drag/Slider functions are only forwarding the min/max values clamping values if the ImGuiSliderFlags_AlwaysClamp flag is set!+// This is intended: this way we allow Ctrl+Click manual input to set a value out of bounds, for maximum flexibility.+// However this may not be ideal for all uses, as some user code may break on out of bound values.+bool ImGui::TempInputScalar(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min, const void* p_clamp_max)+{+ // FIXME: May need to clarify display behavior if format doesn't contain %.+ // "%d" -> "%d" / "There are %d items" -> "%d" / "items" -> "%d" (fallback). Also see #6405+ ImGuiContext& g = *GImGui;+ const ImGuiDataTypeInfo* type_info = DataTypeGetInfo(data_type);+ char fmt_buf[32];+ char data_buf[32];+ format = ImParseFormatTrimDecorations(format, fmt_buf, IM_COUNTOF(fmt_buf));+ if (format[0] == 0)+ format = type_info->PrintFmt;+ DataTypeFormatString(data_buf, IM_COUNTOF(data_buf), data_type, p_data, format);+ ImStrTrimBlanks(data_buf);++ ImGuiInputTextFlags flags = ImGuiInputTextFlags_AutoSelectAll | (ImGuiInputTextFlags)ImGuiInputTextFlags_LocalizeDecimalPoint;+ g.LastItemData.ItemFlags |= ImGuiItemFlags_NoMarkEdited; // Because TempInputText() uses ImGuiInputTextFlags_MergedItem it doesn't submit a new item, so we poke LastItemData.+ g.LastItemData.ItemFlags = (g.LastItemData.ItemFlags & ImGuiItemFlags_LiveEditOnInputScalar) ? (g.LastItemData.ItemFlags | ImGuiItemFlags_LiveEditOnInputText) : (g.LastItemData.ItemFlags & ~ImGuiItemFlags_LiveEditOnInputText);+ if (!TempInputText(bb, id, label, data_buf, IM_COUNTOF(data_buf), flags))+ return false;++ // Backup old value+ size_t data_type_size = type_info->Size;+ ImGuiDataTypeStorage data_backup;+ memcpy(&data_backup, p_data, data_type_size);++ // Apply new value (or operations) then clamp+ DataTypeApplyFromText(data_buf, data_type, p_data, format, NULL);+ if (p_clamp_min || p_clamp_max)+ {+ if (p_clamp_min && p_clamp_max && DataTypeCompare(data_type, p_clamp_min, p_clamp_max) > 0)+ ImSwap(p_clamp_min, p_clamp_max);+ DataTypeClamp(data_type, p_data, p_clamp_min, p_clamp_max);+ }++ // Only mark as edited if new value is different+ g.LastItemData.ItemFlags &= ~ImGuiItemFlags_NoMarkEdited;+ bool value_changed = memcmp(&data_backup, p_data, data_type_size) != 0;+ if (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue)+ if (ImGuiInputTextState* state = GetInputTextState(g.LastItemData.ID))+ value_changed |= (g.LastItemData.ItemFlags & ImGuiItemFlags_LiveEditOnInputScalar) ? (state->EditedThisFrame | state->ValidatedThisFrame) : state->ValidatedThisFrame;++ if (value_changed)+ MarkItemEdited(id);+ return value_changed;+}++void ImGui::SetNextItemRefVal(ImGuiDataType data_type, void* p_data)+{+ ImGuiContext& g = *GImGui;+ g.NextItemData.HasFlags |= ImGuiNextItemDataFlags_HasRefVal;+ memcpy(&g.NextItemData.RefVal, p_data, DataTypeGetInfo(data_type)->Size);+}++// Note: p_data, p_step, p_step_fast are _pointers_ to a memory address holding the data. For an Input widget, p_step and p_step_fast are optional.+// Read code of e.g. InputFloat(), InputInt() etc. or examples in 'Demo->Widgets->Data Types' to understand how to use this function directly.+bool ImGui::InputScalar(const char* label, ImGuiDataType data_type, void* p_data, const void* p_step, const void* p_step_fast, const char* format, ImGuiInputTextFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ ImGuiStyle& style = g.Style;+ //IM_ASSERT((flags & ImGuiInputTextFlags_EnterReturnsTrue) == 0); // Not supported by InputScalar(). Please open an issue if you this would be useful to you. Otherwise use IsItemDeactivatedAfterEdit()!++ if (format == NULL)+ format = DataTypeGetInfo(data_type)->PrintFmt;++ void* p_data_default = (g.NextItemData.HasFlags & ImGuiNextItemDataFlags_HasRefVal) ? &g.NextItemData.RefVal : &g.DataTypeZeroValue;++ char buf[64];+ if ((flags & ImGuiInputTextFlags_DisplayEmptyRefVal) && DataTypeCompare(data_type, p_data, p_data_default) == 0)+ buf[0] = 0;+ else+ DataTypeFormatString(buf, IM_COUNTOF(buf), data_type, p_data, format);++ // Disable the MarkItemEdited() call in InputText but keep ImGuiItemStatusFlags_Edited.+ // We call MarkItemEdited() ourselves by comparing the actual data rather than the string.+ g.NextItemData.ItemFlagsSet |= ImGuiItemFlags_NoMarkEdited;+ flags |= ImGuiInputTextFlags_AutoSelectAll | (ImGuiInputTextFlags)ImGuiInputTextFlags_LocalizeDecimalPoint;++ const bool has_step_buttons = (p_step != NULL);+ const float button_size = has_step_buttons ? GetFrameHeight() : 0.0f;+ bool ret;+ if (has_step_buttons)+ {+ // With Step Buttons+ BeginGroup(); // The only purpose of the group here is to allow the caller to query item data e.g. IsItemActive()+ PushID(label);+ SetNextItemWidth(ImMax(1.0f, CalcItemWidth() - (button_size + style.ItemInnerSpacing.x) * 2));+ ret = InputText("", buf, IM_COUNTOF(buf), flags); // PushID(label) + "" gives us the expected ID from outside point of view+ IMGUI_TEST_ENGINE_ITEM_INFO(g.LastItemData.ID, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Inputable);+ }+ else+ {+ // Without Step Buttons+ ret = InputText(label, buf, IM_COUNTOF(buf), flags);+ }++ // Apply+ bool value_changed = false;+ if (g.LastItemData.ItemFlags & ImGuiItemFlags_LiveEditOnInputScalar)+ {+ bool input_edited = (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_EditedInternal) != 0; // We would be using 'ret' if ImGuiInputTextFlags_EnterReturnsTrue was not involved.+ if (input_edited)+ value_changed = DataTypeApplyFromText(buf, data_type, p_data, format, (flags & ImGuiInputTextFlags_ParseEmptyRefVal) ? p_data_default : NULL);+ }+ else+ {+ //g.LastItemData.StatusFlags &= ~ImGuiItemStatusFlags_Edited;+ if (g.DeactivatedItemData.ID == g.LastItemData.ID)+ {+ //g.DeactivatedItemData.HasBeenEditedBefore = false; // Will be set below by MarkItemEdited()+ //if (IsItemDeactivated()) // Should be unnecessary+ value_changed = DataTypeApplyFromText(buf, data_type, p_data, format, (flags & ImGuiInputTextFlags_ParseEmptyRefVal) ? p_data_default : NULL);+ }+ }+ if (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue)+ if (ImGuiInputTextState* state = GetInputTextState(g.LastItemData.ID))+ value_changed |= (g.LastItemData.ItemFlags & ImGuiItemFlags_LiveEditOnInputScalar) ? (state->EditedThisFrame | state->ValidatedThisFrame) : state->ValidatedThisFrame;++ // Step buttons+ if (has_step_buttons)+ {+ const ImVec2 backup_frame_padding = style.FramePadding;+ style.FramePadding.x = style.FramePadding.y;+ if (flags & ImGuiInputTextFlags_ReadOnly)+ BeginDisabled();+ PushItemFlag(ImGuiItemFlags_ButtonRepeat, true);+ SameLine(0, style.ItemInnerSpacing.x);+ if (ButtonEx("-", ImVec2(button_size, button_size)))+ {+ DataTypeApplyOp(data_type, '-', p_data, p_data, g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);+ value_changed = ret = true;+ }+ SameLine(0, style.ItemInnerSpacing.x);+ if (ButtonEx("+", ImVec2(button_size, button_size)))+ {+ DataTypeApplyOp(data_type, '+', p_data, p_data, g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);+ value_changed = ret = true;+ }+ PopItemFlag();+ if (flags & ImGuiInputTextFlags_ReadOnly)+ EndDisabled();++ const char* label_end = FindRenderedTextEnd(label);+ if (label != label_end)+ {+ SameLine(0, style.ItemInnerSpacing.x);+ TextEx(label, label_end);+ }+ style.FramePadding = backup_frame_padding;++ PopID();+ EndGroup();+ }++ g.LastItemData.ItemFlags &= ~ImGuiItemFlags_NoMarkEdited;+ if (value_changed)+ MarkItemEdited(g.LastItemData.ID);++ if (flags & ImGuiInputTextFlags_EnterReturnsTrue)+ return ret;+ return value_changed;+}++bool ImGui::InputScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, const void* p_step, const void* p_step_fast, const char* format, ImGuiInputTextFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ bool value_changed = false;+ BeginGroup();+ PushID(label);+ PushMultiItemsWidths(components, CalcItemWidth());+ size_t type_size = GDataTypeInfo[data_type].Size;+ for (int i = 0; i < components; i++)+ {+ PushID(i);+ if (i > 0)+ SameLine(0, g.Style.ItemInnerSpacing.x);+ value_changed |= InputScalar("", data_type, p_data, p_step, p_step_fast, format, flags);+ PopID();+ PopItemWidth();+ p_data = (void*)((char*)p_data + type_size);+ }+ PopID();++ const char* label_end = FindRenderedTextEnd(label);+ if (label != label_end)+ {+ SameLine(0.0f, g.Style.ItemInnerSpacing.x);+ TextEx(label, label_end);+ }++ EndGroup();+ return value_changed;+}++bool ImGui::InputFloat(const char* label, float* v, float step, float step_fast, const char* format, ImGuiInputTextFlags flags)+{+ return InputScalar(label, ImGuiDataType_Float, (void*)v, (void*)(step > 0.0f ? &step : NULL), (void*)(step_fast > 0.0f ? &step_fast : NULL), format, flags);+}++bool ImGui::InputFloat2(const char* label, float v[2], const char* format, ImGuiInputTextFlags flags)+{+ return InputScalarN(label, ImGuiDataType_Float, v, 2, NULL, NULL, format, flags);+}++bool ImGui::InputFloat3(const char* label, float v[3], const char* format, ImGuiInputTextFlags flags)+{+ return InputScalarN(label, ImGuiDataType_Float, v, 3, NULL, NULL, format, flags);+}++bool ImGui::InputFloat4(const char* label, float v[4], const char* format, ImGuiInputTextFlags flags)+{+ return InputScalarN(label, ImGuiDataType_Float, v, 4, NULL, NULL, format, flags);+}++bool ImGui::InputInt(const char* label, int* v, int step, int step_fast, ImGuiInputTextFlags flags)+{+ // Hexadecimal input provided as a convenience but the flag name is awkward. Typically you'd use InputText() to parse your own data, if you want to handle prefixes.+ const char* format = (flags & ImGuiInputTextFlags_CharsHexadecimal) ? "%08X" : "%d";+ return InputScalar(label, ImGuiDataType_S32, (void*)v, (void*)(step > 0 ? &step : NULL), (void*)(step_fast > 0 ? &step_fast : NULL), format, flags);+}++bool ImGui::InputInt2(const char* label, int v[2], ImGuiInputTextFlags flags)+{+ return InputScalarN(label, ImGuiDataType_S32, v, 2, NULL, NULL, "%d", flags);+}++bool ImGui::InputInt3(const char* label, int v[3], ImGuiInputTextFlags flags)+{+ return InputScalarN(label, ImGuiDataType_S32, v, 3, NULL, NULL, "%d", flags);+}++bool ImGui::InputInt4(const char* label, int v[4], ImGuiInputTextFlags flags)+{+ return InputScalarN(label, ImGuiDataType_S32, v, 4, NULL, NULL, "%d", flags);+}++bool ImGui::InputDouble(const char* label, double* v, double step, double step_fast, const char* format, ImGuiInputTextFlags flags)+{+ return InputScalar(label, ImGuiDataType_Double, (void*)v, (void*)(step > 0.0 ? &step : NULL), (void*)(step_fast > 0.0 ? &step_fast : NULL), format, flags);+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: InputText, InputTextMultiline, InputTextWithHint+//-------------------------------------------------------------------------+// - imstb_textedit.h include+// - InputText()+// - InputTextWithHint()+// - InputTextMultiline()+// - InputTextEx() [Internal]+// - DebugNodeInputTextState() [Internal]+//-------------------------------------------------------------------------++namespace ImStb+{+#include "imstb_textedit.h"+}++// If you want to use InputText() with std::string or any custom dynamic string type, use the wrapper in misc/cpp/imgui_stdlib.h/.cpp!+bool ImGui::InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)+{+ IM_ASSERT(!(flags & ImGuiInputTextFlags_Multiline)); // call InputTextMultiline()+ return InputTextEx(label, NULL, buf, (int)buf_size, ImVec2(0, 0), flags, callback, user_data);+}++bool ImGui::InputTextMultiline(const char* label, char* buf, size_t buf_size, const ImVec2& size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)+{+ return InputTextEx(label, NULL, buf, (int)buf_size, size, flags | ImGuiInputTextFlags_Multiline, callback, user_data);+}++bool ImGui::InputTextWithHint(const char* label, const char* hint, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)+{+ IM_ASSERT(!(flags & ImGuiInputTextFlags_Multiline)); // call InputTextMultiline() or InputTextEx() manually if you need multi-line + hint.+ return InputTextEx(label, hint, buf, (int)buf_size, ImVec2(0, 0), flags, callback, user_data);+}++static ImVec2 InputTextCalcTextSize(ImGuiContext* ctx, const char* text_begin, const char* text_end_display, const char* text_end, const char** out_remaining, ImVec2* out_offset, ImDrawTextFlags flags)+{+ ImGuiContext& g = *ctx;+ ImGuiInputTextState* obj = &g.InputTextState;+ IM_ASSERT(text_end_display >= text_begin && text_end_display <= text_end);+ return ImFontCalcTextSizeEx(g.Font, g.FontSize, FLT_MAX, obj->WrapWidth, text_begin, text_end_display, text_end, out_remaining, out_offset, flags);+}++// Wrapper for stb_textedit.h to edit text (our wrapper is for: statically sized buffer, single-line, wchar characters. InputText converts between UTF-8 and wchar)+// With our UTF-8 use of stb_textedit:+// - STB_TEXTEDIT_GETCHAR is nothing more than a a "GETBYTE". It's only used to compare to ascii or to copy blocks of text so we are fine.+// - One exception is the STB_TEXTEDIT_IS_SPACE feature which would expect a full char in order to handle full-width space such as 0x3000 (see ImCharIsBlankW).+// - ...but we don't use that feature.+namespace ImStb+{+static int STB_TEXTEDIT_STRINGLEN(const ImGuiInputTextState* obj) { return obj->TextLen; }+static char STB_TEXTEDIT_GETCHAR(const ImGuiInputTextState* obj, int idx) { IM_ASSERT(idx >= 0 && idx <= obj->TextLen); return obj->TextSrc[idx]; }+static float STB_TEXTEDIT_GETWIDTH(ImGuiInputTextState* obj, int line_start_idx, int char_idx) { unsigned int c; ImTextCharFromUtf8(&c, obj->TextSrc + line_start_idx + char_idx, obj->TextSrc + obj->TextLen); if ((ImWchar)c == '\n') return IMSTB_TEXTEDIT_GETWIDTH_NEWLINE; ImGuiContext& g = *obj->Ctx; return g.FontBaked->GetCharAdvance((ImWchar)c) * g.FontBakedScale; }+static char STB_TEXTEDIT_NEWLINE = '\n';+static void STB_TEXTEDIT_LAYOUTROW(StbTexteditRow* r, ImGuiInputTextState* obj, int line_start_idx)+{+ const char* text = obj->TextSrc;+ const char* text_remaining = NULL;+ const ImVec2 size = InputTextCalcTextSize(obj->Ctx, text + line_start_idx, text + obj->TextLen, text + obj->TextLen, &text_remaining, NULL, ImDrawTextFlags_StopOnNewLine | ImDrawTextFlags_WrapKeepBlanks);+ r->x0 = 0.0f;+ r->x1 = size.x;+ r->baseline_y_delta = size.y;+ r->ymin = 0.0f;+ r->ymax = size.y;+ r->num_chars = (int)(text_remaining - (text + line_start_idx));+}++#define IMSTB_TEXTEDIT_GETNEXTCHARINDEX IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL+#define IMSTB_TEXTEDIT_GETPREVCHARINDEX IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL++static int IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL(ImGuiInputTextState* obj, int idx)+{+ if (idx >= obj->TextLen)+ return obj->TextLen + 1;+ unsigned int c;+ return idx + ImTextCharFromUtf8(&c, obj->TextSrc + idx, obj->TextSrc + obj->TextLen);+}++static int IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL(ImGuiInputTextState* obj, int idx)+{+ if (idx <= 0)+ return -1;+ const char* p = ImTextFindPreviousUtf8Codepoint(obj->TextSrc, obj->TextSrc + idx);+ return (int)(p - obj->TextSrc);+}++static bool ImCharIsSeparatorW(unsigned int c)+{+ static const unsigned int separator_list[] =+ {+ ',', 0x3001, '.', 0x3002, ';', 0xFF1B, '(', 0xFF08, ')', 0xFF09, '{', 0xFF5B, '}', 0xFF5D,+ '[', 0x300C, ']', 0x300D, '|', 0xFF5C, '!', 0xFF01, '\\', 0xFFE5, '/', 0x30FB, 0xFF0F,+ '\n', '\r',+ };+ for (unsigned int separator : separator_list)+ if (c == separator)+ return true;+ return false;+}++static int is_word_boundary_from_right(ImGuiInputTextState* obj, int idx)+{+ // When ImGuiInputTextFlags_Password is set, we don't want actions such as Ctrl+Arrow to leak the fact that underlying data are blanks or separators.+ if ((obj->Flags & ImGuiInputTextFlags_Password) || idx <= 0)+ return 0;++ const char* curr_p = obj->TextSrc + idx;+ const char* prev_p = ImTextFindPreviousUtf8Codepoint(obj->TextSrc, curr_p);+ unsigned int curr_c; ImTextCharFromUtf8(&curr_c, curr_p, obj->TextSrc + obj->TextLen);+ unsigned int prev_c; ImTextCharFromUtf8(&prev_c, prev_p, obj->TextSrc + obj->TextLen);++ bool prev_white = ImCharIsBlankW(prev_c);+ bool prev_separ = ImCharIsSeparatorW(prev_c);+ bool curr_white = ImCharIsBlankW(curr_c);+ bool curr_separ = ImCharIsSeparatorW(curr_c);+ return ((prev_white || prev_separ) && !(curr_separ || curr_white)) || (curr_separ && !prev_separ);+}+static int is_word_boundary_from_left(ImGuiInputTextState* obj, int idx)+{+ if ((obj->Flags & ImGuiInputTextFlags_Password) || idx <= 0)+ return 0;++ const char* curr_p = obj->TextSrc + idx;+ const char* prev_p = ImTextFindPreviousUtf8Codepoint(obj->TextSrc, curr_p);+ unsigned int prev_c; ImTextCharFromUtf8(&prev_c, curr_p, obj->TextSrc + obj->TextLen);+ unsigned int curr_c; ImTextCharFromUtf8(&curr_c, prev_p, obj->TextSrc + obj->TextLen);++ bool prev_white = ImCharIsBlankW(prev_c);+ bool prev_separ = ImCharIsSeparatorW(prev_c);+ bool curr_white = ImCharIsBlankW(curr_c);+ bool curr_separ = ImCharIsSeparatorW(curr_c);+ return ((prev_white) && !(curr_separ || curr_white)) || (curr_separ && !prev_separ);+}+static int STB_TEXTEDIT_MOVEWORDLEFT_IMPL(ImGuiInputTextState* obj, int idx)+{+ idx = IMSTB_TEXTEDIT_GETPREVCHARINDEX(obj, idx);+ while (idx >= 0 && !is_word_boundary_from_right(obj, idx))+ idx = IMSTB_TEXTEDIT_GETPREVCHARINDEX(obj, idx);+ return idx < 0 ? 0 : idx;+}+static int STB_TEXTEDIT_MOVEWORDRIGHT_MAC(ImGuiInputTextState* obj, int idx)+{+ int len = obj->TextLen;+ idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);+ while (idx < len && !is_word_boundary_from_left(obj, idx))+ idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);+ return idx > len ? len : idx;+}+static int STB_TEXTEDIT_MOVEWORDRIGHT_WIN(ImGuiInputTextState* obj, int idx)+{+ idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);+ int len = obj->TextLen;+ while (idx < len && !is_word_boundary_from_right(obj, idx))+ idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);+ return idx > len ? len : idx;+}+static int STB_TEXTEDIT_MOVEWORDRIGHT_IMPL(ImGuiInputTextState* obj, int idx) { ImGuiContext& g = *obj->Ctx; if (g.IO.ConfigMacOSXBehaviors) return STB_TEXTEDIT_MOVEWORDRIGHT_MAC(obj, idx); else return STB_TEXTEDIT_MOVEWORDRIGHT_WIN(obj, idx); }+#define STB_TEXTEDIT_MOVEWORDLEFT STB_TEXTEDIT_MOVEWORDLEFT_IMPL // They need to be #define for stb_textedit.h+#define STB_TEXTEDIT_MOVEWORDRIGHT STB_TEXTEDIT_MOVEWORDRIGHT_IMPL++// Reimplementation of stb_textedit_move_line_start()/stb_textedit_move_line_end() which supports word-wrapping.+static int STB_TEXTEDIT_MOVELINESTART_IMPL(ImGuiInputTextState* obj, ImStb::STB_TexteditState* state, int cursor)+{+ if (state->single_line)+ return 0;++ if (obj->WrapWidth > 0.0f)+ {+ ImGuiContext& g = *obj->Ctx;+ const char* p_cursor = obj->TextSrc + cursor;+ const char* p_bol = ImStrbol(p_cursor, obj->TextSrc);+ const char* p = p_bol;+ const char* text_end = obj->TextSrc + obj->TextLen; // End of line would be enough+ while (p >= p_bol)+ {+ const char* p_eol = ImFontCalcWordWrapPositionEx(g.Font, g.FontSize, p, text_end, obj->WrapWidth, ImDrawTextFlags_WrapKeepBlanks);+ if (p == p_cursor) // If we are already on a visible beginning-of-line, return real beginning-of-line (would be same as regular handler below)+ return (int)(p_bol - obj->TextSrc);+ if (p_eol == p_cursor && obj->TextSrc[cursor] != '\n' && obj->LastMoveDirectionLR == ImGuiDir_Left)+ return (int)(p_bol - obj->TextSrc);+ if (p_eol >= p_cursor)+ return (int)(p - obj->TextSrc);+ p = (*p_eol == '\n') ? p_eol + 1 : p_eol;+ }+ }++ // Regular handler, same as stb_textedit_move_line_start()+ while (cursor > 0)+ {+ int prev_cursor = IMSTB_TEXTEDIT_GETPREVCHARINDEX(obj, cursor);+ if (STB_TEXTEDIT_GETCHAR(obj, prev_cursor) == STB_TEXTEDIT_NEWLINE)+ break;+ cursor = prev_cursor;+ }+ return cursor;+}++static int STB_TEXTEDIT_MOVELINEEND_IMPL(ImGuiInputTextState* obj, ImStb::STB_TexteditState* state, int cursor)+{+ int n = STB_TEXTEDIT_STRINGLEN(obj);+ if (state->single_line)+ return n;++ if (obj->WrapWidth > 0.0f)+ {+ ImGuiContext& g = *obj->Ctx;+ const char* p_cursor = obj->TextSrc + cursor;+ const char* p = ImStrbol(p_cursor, obj->TextSrc);+ const char* text_end = obj->TextSrc + obj->TextLen; // End of line would be enough+ while (p < text_end)+ {+ const char* p_eol = ImFontCalcWordWrapPositionEx(g.Font, g.FontSize, p, text_end, obj->WrapWidth, ImDrawTextFlags_WrapKeepBlanks);+ cursor = (int)(p_eol - obj->TextSrc);+ if (p_eol == p_cursor && obj->LastMoveDirectionLR != ImGuiDir_Left) // If we are already on a visible end-of-line, switch to regular handle+ break;+ if (p_eol > p_cursor)+ return cursor;+ p = (*p_eol == '\n') ? p_eol + 1 : p_eol;+ }+ }+ // Regular handler, same as stb_textedit_move_line_end()+ while (cursor < n && STB_TEXTEDIT_GETCHAR(obj, cursor) != STB_TEXTEDIT_NEWLINE)+ cursor = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, cursor);+ return cursor;+}++#define STB_TEXTEDIT_MOVELINESTART STB_TEXTEDIT_MOVELINESTART_IMPL+#define STB_TEXTEDIT_MOVELINEEND STB_TEXTEDIT_MOVELINEEND_IMPL++static void STB_TEXTEDIT_DELETECHARS(ImGuiInputTextState* obj, int pos, int n)+{+ // Offset remaining text (+ copy zero terminator)+ IM_ASSERT(obj->TextSrc == obj->TextA.Data);+ char* dst = obj->TextA.Data + pos;+ char* src = obj->TextA.Data + pos + n;+ memmove(dst, src, obj->TextLen - n - pos + 1);+ obj->EditedBefore = obj->EditedThisFrame = true;+ obj->TextLen -= n;+}++static int STB_TEXTEDIT_INSERTCHARS(ImGuiInputTextState* obj, int pos, const char* new_text, int new_text_len)+{+ const bool is_resizable = (obj->Flags & ImGuiInputTextFlags_CallbackResize) != 0;+ const int text_len = obj->TextLen;+ IM_ASSERT(pos <= text_len);++ // We support partial insertion (with a mod in stb_textedit.h)+ const int avail = obj->BufCapacity - 1 - obj->TextLen;+ if (!is_resizable && new_text_len > avail)+ new_text_len = (int)(ImTextFindValidUtf8CodepointEnd(new_text, new_text + new_text_len, new_text + avail) - new_text); // Truncate to closest UTF-8 codepoint. Alternative: return 0 to cancel insertion.+ if (new_text_len == 0)+ return 0;++ // Grow internal buffer if needed+ IM_ASSERT(obj->TextSrc == obj->TextA.Data);+ if (text_len + new_text_len + 1 > obj->TextA.Size && is_resizable)+ {+ obj->TextA.resize(text_len + ImClamp(new_text_len, 32, ImMax(256, new_text_len)) + 1);+ obj->TextSrc = obj->TextA.Data;+ }++ char* text = obj->TextA.Data;+ if (pos != text_len)+ memmove(text + pos + new_text_len, text + pos, (size_t)(text_len - pos));+ memcpy(text + pos, new_text, (size_t)new_text_len);++ obj->EditedBefore = obj->EditedThisFrame = true;+ obj->TextLen += new_text_len;+ obj->TextA[obj->TextLen] = '\0';++ return new_text_len;+}++// We don't use an enum so we can build even with conflicting symbols (if another user of stb_textedit.h leak their STB_TEXTEDIT_K_* symbols)+#define STB_TEXTEDIT_K_LEFT 0x200000 // keyboard input to move cursor left+#define STB_TEXTEDIT_K_RIGHT 0x200001 // keyboard input to move cursor right+#define STB_TEXTEDIT_K_UP 0x200002 // keyboard input to move cursor up+#define STB_TEXTEDIT_K_DOWN 0x200003 // keyboard input to move cursor down+#define STB_TEXTEDIT_K_LINESTART 0x200004 // keyboard input to move cursor to start of line+#define STB_TEXTEDIT_K_LINEEND 0x200005 // keyboard input to move cursor to end of line+#define STB_TEXTEDIT_K_TEXTSTART 0x200006 // keyboard input to move cursor to start of text+#define STB_TEXTEDIT_K_TEXTEND 0x200007 // keyboard input to move cursor to end of text+#define STB_TEXTEDIT_K_DELETE 0x200008 // keyboard input to delete selection or character under cursor+#define STB_TEXTEDIT_K_BACKSPACE 0x200009 // keyboard input to delete selection or character left of cursor+#define STB_TEXTEDIT_K_UNDO 0x20000A // keyboard input to perform undo+#define STB_TEXTEDIT_K_REDO 0x20000B // keyboard input to perform redo+#define STB_TEXTEDIT_K_WORDLEFT 0x20000C // keyboard input to move cursor left one word+#define STB_TEXTEDIT_K_WORDRIGHT 0x20000D // keyboard input to move cursor right one word+#define STB_TEXTEDIT_K_PGUP 0x20000E // keyboard input to move cursor up a page+#define STB_TEXTEDIT_K_PGDOWN 0x20000F // keyboard input to move cursor down a page+#define STB_TEXTEDIT_K_SHIFT 0x400000++#define IMSTB_TEXTEDIT_IMPLEMENTATION+#define IMSTB_TEXTEDIT_memmove memmove+#include "imstb_textedit.h"++// stb_textedit internally allows for a single undo record to do addition and deletion, but somehow, calling+// the stb_textedit_paste() function creates two separate records, so we perform it manually. (FIXME: Report to nothings/stb?)+static void stb_textedit_replace(ImGuiInputTextState* str, STB_TexteditState* state, const IMSTB_TEXTEDIT_CHARTYPE* text, int text_len)+{+ stb_text_makeundo_replace(str, state, 0, str->TextLen, text_len);+ ImStb::STB_TEXTEDIT_DELETECHARS(str, 0, str->TextLen);+ state->cursor = state->select_start = state->select_end = 0;+ if (text_len <= 0)+ return;+ int text_len_inserted = ImStb::STB_TEXTEDIT_INSERTCHARS(str, 0, text, text_len);+ if (text_len_inserted > 0)+ {+ state->cursor = state->select_start = state->select_end = text_len;+ state->has_preferred_x = 0;+ return;+ }+ IM_ASSERT(0); // Failed to insert character, normally shouldn't happen because of how we currently use stb_textedit_replace()+}++} // namespace ImStb++// We added an extra indirection where 'Stb' is heap-allocated, in order facilitate the work of bindings generators.+ImGuiInputTextState::ImGuiInputTextState()+{+ memset((void*)this, 0, sizeof(*this));+ Stb = IM_NEW(ImStbTexteditState);+ memset(Stb, 0, sizeof(*Stb));+}++ImGuiInputTextState::~ImGuiInputTextState()+{+ IM_DELETE(Stb);+}++void ImGuiInputTextState::OnKeyPressed(int key)+{+ stb_textedit_key(this, Stb, key);+ CursorFollow = true;+ CursorAnimReset();+ const int key_u = (key & ~STB_TEXTEDIT_K_SHIFT);+ if (key_u == STB_TEXTEDIT_K_LEFT || key_u == STB_TEXTEDIT_K_LINESTART || key_u == STB_TEXTEDIT_K_TEXTSTART || key_u == STB_TEXTEDIT_K_BACKSPACE || key_u == STB_TEXTEDIT_K_WORDLEFT)+ LastMoveDirectionLR = ImGuiDir_Left;+ else if (key_u == STB_TEXTEDIT_K_RIGHT || key_u == STB_TEXTEDIT_K_LINEEND || key_u == STB_TEXTEDIT_K_TEXTEND || key_u == STB_TEXTEDIT_K_DELETE || key_u == STB_TEXTEDIT_K_WORDRIGHT)+ LastMoveDirectionLR = ImGuiDir_Right;+}++void ImGuiInputTextState::OnCharPressed(unsigned int c)+{+ // Convert the key to a UTF8 byte sequence.+ // The changes we had to make to stb_textedit_key made it very much UTF-8 specific which is not too great.+ char utf8[5];+ ImTextCharToUtf8(utf8, c);+ stb_textedit_text(this, Stb, utf8, (int)ImStrlen(utf8));+ CursorFollow = true;+ CursorAnimReset();+}++// Those functions are not inlined in imgui_internal.h, allowing us to hide ImStbTexteditState from that header.+void ImGuiInputTextState::CursorAnimReset() { CursorAnim = -0.30f; } // After a user-input the cursor stays on for a while without blinking+void ImGuiInputTextState::CursorClamp() { Stb->cursor = ImMin(Stb->cursor, TextLen); Stb->select_start = ImMin(Stb->select_start, TextLen); Stb->select_end = ImMin(Stb->select_end, TextLen); }+bool ImGuiInputTextState::HasSelection() const { return Stb->select_start != Stb->select_end; }+void ImGuiInputTextState::ClearSelection() { Stb->select_start = Stb->select_end = Stb->cursor; }+int ImGuiInputTextState::GetCursorPos() const { return Stb->cursor; }+int ImGuiInputTextState::GetSelectionStart() const { return Stb->select_start; }+int ImGuiInputTextState::GetSelectionEnd() const { return Stb->select_end; }+void ImGuiInputTextState::SetSelection(int start, int end) { Stb->select_start = start; Stb->cursor = Stb->select_end = end; }+float ImGuiInputTextState::GetPreferredOffsetX() const { return Stb->has_preferred_x ? Stb->preferred_x : -1; }+void ImGuiInputTextState::SelectAll() { Stb->select_start = 0; Stb->cursor = Stb->select_end = TextLen; Stb->has_preferred_x = 0; }+void ImGuiInputTextState::ReloadUserBufAndSelectAll() { WantReloadUserBuf = true; ReloadSelectionStart = 0; ReloadSelectionEnd = INT_MAX; }+void ImGuiInputTextState::ReloadUserBufAndKeepSelection() { WantReloadUserBuf = true; ReloadSelectionStart = Stb->select_start; ReloadSelectionEnd = Stb->select_end; }+void ImGuiInputTextState::ReloadUserBufAndMoveToEnd() { WantReloadUserBuf = true; ReloadSelectionStart = ReloadSelectionEnd = INT_MAX; }++ImGuiInputTextCallbackData::ImGuiInputTextCallbackData()+{+ memset((void*)this, 0, sizeof(*this));+}++// Public API to manipulate UTF-8 text from within a callback.+// FIXME: The existence of this rarely exercised code path is a bit of a nuisance.+// Historically they existed because STB_TEXTEDIT_INSERTCHARS() etc. worked on our ImWchar+// buffer, but nowadays they both work on UTF-8 data. Should aim to merge both.+void ImGuiInputTextCallbackData::DeleteChars(int pos, int bytes_count)+{+ IM_ASSERT(pos + bytes_count <= BufTextLen);+ char* dst = Buf + pos;+ const char* src = Buf + pos + bytes_count;+ memmove(dst, src, BufTextLen - bytes_count - pos + 1);++ if (CursorPos >= pos + bytes_count)+ CursorPos -= bytes_count;+ else if (CursorPos >= pos)+ CursorPos = pos;+ SelectionStart = SelectionEnd = CursorPos;+ BufDirty = true;+ BufTextLen -= bytes_count;+}++void ImGuiInputTextCallbackData::InsertChars(int pos, const char* new_text, const char* new_text_end)+{+ // Accept null ranges+ if (new_text == new_text_end)+ return;++ ImGuiContext& g = *Ctx;+ ImGuiInputTextState* obj = &g.InputTextState;+ IM_ASSERT(obj->ID != 0 && g.ActiveId == obj->ID);+ const bool is_resizable = (Flags & ImGuiInputTextFlags_CallbackResize) != 0;+ const bool is_readonly = (Flags & ImGuiInputTextFlags_ReadOnly) != 0;+ int new_text_len = new_text_end ? (int)(new_text_end - new_text) : (int)ImStrlen(new_text);++ // We support partial insertion (with a mod in stb_textedit.h)+ const int avail = BufSize - 1 - BufTextLen;+ if (!is_resizable && new_text_len > avail)+ new_text_len = (int)(ImTextFindValidUtf8CodepointEnd(new_text, new_text + new_text_len, new_text + avail) - new_text); // Truncate to closest UTF-8 codepoint. Alternative: return 0 to cancel insertion.+ if (new_text_len == 0)+ return;++ // Grow internal buffer if needed+ if (new_text_len + BufTextLen + 1 > obj->TextA.Size && is_resizable && !is_readonly)+ {+ IM_ASSERT(Buf == obj->TextA.Data);+ int new_buf_size = BufTextLen + ImClamp(new_text_len, 32, ImMax(256, new_text_len)) + 1;+ obj->TextA.resize(new_buf_size + 1);+ obj->TextSrc = obj->TextA.Data;+ Buf = obj->TextA.Data;+ BufSize = obj->BufCapacity = new_buf_size;+ }++ if (BufTextLen != pos)+ memmove(Buf + pos + new_text_len, Buf + pos, (size_t)(BufTextLen - pos));+ memcpy(Buf + pos, new_text, (size_t)new_text_len * sizeof(char));+ Buf[BufTextLen + new_text_len] = '\0';++ BufDirty = true;+ BufTextLen += new_text_len;+ if (CursorPos >= pos)+ CursorPos += new_text_len;+ CursorPos = ImClamp(CursorPos, 0, BufTextLen);+ SelectionStart = SelectionEnd = CursorPos;+}++void ImGui::PushPasswordFont()+{+ ImGuiContext& g = *GImGui;+ ImFontBaked* backup = &g.InputTextPasswordFontBackupBaked;+ IM_ASSERT(backup->IndexAdvanceX.Size == 0 && backup->IndexLookup.Size == 0);+ ImFontGlyph* glyph = g.FontBaked->FindGlyph('*');+ g.InputTextPasswordFontBackupFlags = g.Font->Flags;+ backup->FallbackGlyphIndex = g.FontBaked->FallbackGlyphIndex;+ backup->FallbackAdvanceX = g.FontBaked->FallbackAdvanceX;+ backup->IndexLookup.swap(g.FontBaked->IndexLookup);+ backup->IndexAdvanceX.swap(g.FontBaked->IndexAdvanceX);+ g.Font->Flags |= ImFontFlags_NoLoadGlyphs;+ g.FontBaked->FallbackGlyphIndex = g.FontBaked->Glyphs.index_from_ptr(glyph);+ g.FontBaked->FallbackAdvanceX = glyph->AdvanceX;+}++void ImGui::PopPasswordFont()+{+ ImGuiContext& g = *GImGui;+ ImFontBaked* backup = &g.InputTextPasswordFontBackupBaked;+ g.Font->Flags = g.InputTextPasswordFontBackupFlags;+ g.FontBaked->FallbackGlyphIndex = backup->FallbackGlyphIndex;+ g.FontBaked->FallbackAdvanceX = backup->FallbackAdvanceX;+ g.FontBaked->IndexLookup.swap(backup->IndexLookup);+ g.FontBaked->IndexAdvanceX.swap(backup->IndexAdvanceX);+ IM_ASSERT(backup->IndexAdvanceX.Size == 0 && backup->IndexLookup.Size == 0);+}++// Return false to discard a character.+static bool InputTextFilterCharacter(ImGuiContext* ctx, ImGuiInputTextState* state, unsigned int* p_char, ImGuiInputTextCallback callback, void* user_data, bool input_source_is_clipboard)+{+ IM_ASSERT(state != NULL);+ unsigned int c = *p_char;+ ImGuiInputTextFlags flags = state->Flags;++ // Filter non-printable (NB: isprint is unreliable! see #2467)+ bool apply_named_filters = true;+ if (c < 0x20)+ {+ bool pass = false;+ pass |= (c == '\n') && (flags & ImGuiInputTextFlags_Multiline) != 0; // Note that an Enter KEY will emit \r and be ignored (we poll for KEY in InputText() code)+ if (c == '\n' && input_source_is_clipboard && (flags & ImGuiInputTextFlags_Multiline) == 0) // In single line mode, replace \n with a space+ {+ c = *p_char = ' ';+ pass = true;+ }+ pass |= (c == '\n') && (flags & ImGuiInputTextFlags_Multiline) != 0;+ pass |= (c == '\t') && (flags & ImGuiInputTextFlags_AllowTabInput) != 0;+ if (!pass)+ return false;+ apply_named_filters = false; // Override named filters below so newline and tabs can still be inserted.+ }++ if (input_source_is_clipboard == false)+ {+ // We ignore Ascii representation of delete (emitted from Backspace on OSX, see #2578, #2817)+ if (c == 127)+ return false;++ // Filter private Unicode range. GLFW on OSX seems to send private characters for special keys like arrow keys (FIXME)+ if (c >= 0xE000 && c <= 0xF8FF)+ return false;+ }++ // Filter Unicode ranges we are not handling in this build+ if (c > IM_UNICODE_CODEPOINT_MAX)+ return false;++ // Generic named filters+ if (apply_named_filters && (flags & (ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase | ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_CharsScientific | (ImGuiInputTextFlags)ImGuiInputTextFlags_LocalizeDecimalPoint)))+ {+ // The libc allows overriding locale, with e.g. 'setlocale(LC_NUMERIC, "de_DE.UTF-8");' which affect the output/input of printf/scanf to use e.g. ',' instead of '.'.+ // The standard mandate that programs starts in the "C" locale where the decimal point is '.'.+ // We don't really intend to provide widespread support for it, but out of empathy for people stuck with using odd API, we support the bare minimum aka overriding the decimal point.+ // Change the default decimal_point with:+ // ImGui::GetPlatformIO()->Platform_LocaleDecimalPoint = *localeconv()->decimal_point;+ // Users of non-default decimal point (in particular ',') may be affected by word-selection logic (is_word_boundary_from_right/is_word_boundary_from_left) functions.+ ImGuiContext& g = *ctx;+ const unsigned c_decimal_point = (unsigned int)g.PlatformIO.Platform_LocaleDecimalPoint;+ if (flags & (ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsScientific | (ImGuiInputTextFlags)ImGuiInputTextFlags_LocalizeDecimalPoint))+ if (c == '.' || c == ',')+ c = c_decimal_point;++ // Full-width -> half-width conversion for numeric fields: https://en.wikipedia.org/wiki/Halfwidth_and_Fullwidth_Forms_(Unicode_block)+ // While this is mostly convenient, this has the side-effect for uninformed users accidentally inputting full-width characters that they may+ // scratch their head as to why it works in numerical fields vs in generic text fields it would require support in the font.+ if (flags & (ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsScientific | ImGuiInputTextFlags_CharsHexadecimal))+ if (c >= 0xFF01 && c <= 0xFF5E)+ c = c - 0xFF01 + 0x21;++ // Allow 0-9 . - + * /+ if (flags & ImGuiInputTextFlags_CharsDecimal)+ if (!(c >= '0' && c <= '9') && (c != c_decimal_point) && (c != '-') && (c != '+') && (c != '*') && (c != '/'))+ return false;++ // Allow 0-9 . - + * / e E+ if (flags & ImGuiInputTextFlags_CharsScientific)+ if (!(c >= '0' && c <= '9') && (c != c_decimal_point) && (c != '-') && (c != '+') && (c != '*') && (c != '/') && (c != 'e') && (c != 'E'))+ return false;++ // Allow 0-9 a-F A-F+ if (flags & ImGuiInputTextFlags_CharsHexadecimal)+ if (!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F'))+ return false;++ // Turn a-z into A-Z+ if (flags & ImGuiInputTextFlags_CharsUppercase)+ if (c >= 'a' && c <= 'z')+ c += (unsigned int)('A' - 'a');++ if (flags & ImGuiInputTextFlags_CharsNoBlank)+ if (ImCharIsBlankW(c))+ return false;++ *p_char = c;+ }++ // Custom callback filter+ if (flags & ImGuiInputTextFlags_CallbackCharFilter)+ {+ ImGuiContext& g = *GImGui;+ ImGuiInputTextCallbackData callback_data;+ callback_data.Ctx = &g;+ callback_data.ID = state->ID;+ callback_data.Flags = flags;+ callback_data.EventFlag = ImGuiInputTextFlags_CallbackCharFilter;+ callback_data.EventChar = (ImWchar)c;+ callback_data.EventActivated = (g.ActiveId == state->ID && g.ActiveIdIsJustActivated);+ callback_data.CursorPos = state->Stb->cursor;+ callback_data.SelectionStart = state->Stb->select_start;+ callback_data.SelectionEnd = state->Stb->select_end;+ callback_data.UserData = user_data;+ if (callback(&callback_data) != 0)+ return false;+ *p_char = callback_data.EventChar;+ if (!callback_data.EventChar)+ return false;+ }++ return true;+}++// Find the shortest single replacement we can make to get from old_buf to new_buf+// Note that this doesn't directly alter state->TextA, state->TextLen. They are expected to be made valid separately.+// FIXME: Ideally we should transition toward (1) making InsertChars()/DeleteChars() update undo-stack (2) discourage (and keep reconcile) or obsolete (and remove reconcile) accessing buffer directly.+static void InputTextReconcileUndoState(ImGuiInputTextState* state, const char* old_buf, int old_length, const char* new_buf, int new_length)+{+ const int shorter_length = ImMin(old_length, new_length);+ int first_diff;+ for (first_diff = 0; first_diff < shorter_length; first_diff++)+ if (old_buf[first_diff] != new_buf[first_diff])+ break;+ if (first_diff == old_length && first_diff == new_length)+ return;++ int old_last_diff = old_length - 1;+ int new_last_diff = new_length - 1;+ for (; old_last_diff >= first_diff && new_last_diff >= first_diff; old_last_diff--, new_last_diff--)+ if (old_buf[old_last_diff] != new_buf[new_last_diff])+ break;++ const int insert_len = new_last_diff - first_diff + 1;+ const int delete_len = old_last_diff - first_diff + 1;+ if (insert_len > 0 || delete_len > 0)+ if (IMSTB_TEXTEDIT_CHARTYPE* p = stb_text_createundo(&state->Stb->undostate, first_diff, delete_len, insert_len))+ for (int i = 0; i < delete_len; i++)+ p[i] = old_buf[first_diff + i];+}++// As InputText() retain textual data and we currently provide a path for user to not retain it (via local variables)+// we need some form of hook to reapply data back to user buffer on deactivation frame. (#4714)+// It would be more desirable that we discourage users from taking advantage of the "user not retaining data" trick,+// but that more likely be attractive when we do have _NoLiveEdit flag available.+void ImGui::InputTextDeactivateHook(ImGuiID id)+{+ ImGuiContext& g = *GImGui;+ ImGuiInputTextState* state = &g.InputTextState;+ if (id == 0 || state->ID != id || g.ActiveId != id)+ return;+ if (!state->EditedBefore)+ return;+ //IMGUI_DEBUG_LOG_ACTIVEID("InputTextDeactivateHook() id = 0x%08X\n", id);+ state->EditedBefore = false;+ g.InputTextDeactivatedState.ID = state->ID;+ g.InputTextDeactivatedState.ElapseFrame = g.FrameCount + 1;+ if (state->Flags & ImGuiInputTextFlags_ReadOnly)+ {+ g.InputTextDeactivatedState.TextA.resize(0); // In theory this data won't be used, but clear to be neat.+ }+ else+ {+ IM_ASSERT(state->TextA.Data != 0);+ IM_ASSERT(state->TextA[state->TextLen] == 0);+ g.InputTextDeactivatedState.TextA.resize(state->TextLen + 1);+ memcpy(g.InputTextDeactivatedState.TextA.Data, state->TextA.Data, state->TextLen + 1);+ }+}++static int* ImLowerBound(int* in_begin, int* in_end, int v)+{+ int* in_p = in_begin;+ for (size_t count = (size_t)(in_end - in_p); count > 0; )+ {+ size_t count2 = count >> 1;+ int* mid = in_p + count2;+ if (*mid < v)+ {+ in_p = ++mid;+ count -= count2 + 1;+ }+ else+ {+ count = count2;+ }+ }+ return in_p;+}++// FIXME-WORDWRAP: Bundle some of this into ImGuiTextIndex and/or extract as a different tool?+// 'max_output_buffer_size' happens to be a meaningful optimization to avoid writing the full line_index when not necessarily needed (e.g. very large buffer, scrolled up, inactive)+static int InputTextLineIndexBuild(ImGuiInputTextFlags flags, ImGuiTextIndex* line_index, const char* buf, const char* buf_end, float wrap_width, int max_output_buffer_size, const char** out_buf_end)+{+ ImGuiContext& g = *GImGui;+ int size = 0;+ const char* s;+ bool trailing_line_already_counted = false;+ if (flags & ImGuiInputTextFlags_WordWrap)+ {+ for (s = buf; s < buf_end; s = (*s == '\n') ? s + 1 : s)+ {+ if (size++ <= max_output_buffer_size)+ line_index->Offsets.push_back((int)(s - buf));+ s = ImFontCalcWordWrapPositionEx(g.Font, g.FontSize, s, buf_end, wrap_width, ImDrawTextFlags_WrapKeepBlanks);+ }+ }+ else if (buf_end != NULL)+ {+ for (s = buf; s < buf_end; s = s ? s + 1 : buf_end)+ {+ if (size++ <= max_output_buffer_size)+ line_index->Offsets.push_back((int)(s - buf));+ s = (const char*)ImMemchr(s, '\n', buf_end - s);+ }+ }+ else+ {+ // Inactive path: we don't know buf_end ahead of time.+ const char* s_eol;+ for (s = buf; ; s = s_eol + 1)+ {+ if (size++ <= max_output_buffer_size)+ line_index->Offsets.push_back((int)(s - buf));+ if ((s_eol = strchr(s, '\n')) != NULL)+ continue;+ s += strlen(s);+ trailing_line_already_counted = true;+ break;+ }+ }+ if (out_buf_end != NULL)+ *out_buf_end = buf_end = s;+ if (size == 0)+ {+ line_index->Offsets.push_back(0);+ size++;+ }+ if (buf_end > buf && buf_end[-1] == '\n' && !trailing_line_already_counted && size++ <= max_output_buffer_size)+ line_index->Offsets.push_back((int)(buf_end - buf));+ return size;+}++static ImVec2 InputTextLineIndexGetPosOffset(ImGuiContext& g, ImGuiInputTextState* state, ImGuiTextIndex* line_index, const char* buf, const char* buf_end, int cursor_n)+{+ const char* cursor_ptr = buf + cursor_n;+ int* it_begin = line_index->Offsets.begin();+ int* it_end = line_index->Offsets.end();+ const int* it = ImLowerBound(it_begin, it_end, cursor_n);+ if (it > it_begin)+ if (it == it_end || *it != cursor_n || (state != NULL && state->WrapWidth > 0.0f && state->LastMoveDirectionLR == ImGuiDir_Right && cursor_ptr[-1] != '\n' && cursor_ptr[-1] != 0))+ it--;++ const int line_no = (it == it_begin) ? 0 : line_index->Offsets.index_from_ptr(it);+ const char* line_start = line_index->get_line_begin(buf, line_no);+ ImVec2 offset;+ offset.x = InputTextCalcTextSize(&g, line_start, cursor_ptr, buf_end, NULL, NULL, ImDrawTextFlags_WrapKeepBlanks).x;+ offset.y = (line_no + 1) * g.FontSize;+ return offset;+}++// Edit a string of text+// - buf_size account for the zero-terminator, so a buf_size of 6 can hold "Hello" but not "Hello!".+// This is so we can easily call InputText() on static arrays using ARRAYSIZE() and to match+// Note that in std::string world, capacity() would omit 1 byte used by the zero-terminator.+// - When active, hold on a privately held copy of the text (and apply back to 'buf'). So changing 'buf' while the InputText is active has no effect.+// - If you want to use InputText() with std::string or any custom dynamic string type, use the wrapper in misc/cpp/imgui_stdlib.h/.cpp!+bool ImGui::InputTextEx(const char* label, const char* hint, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* callback_user_data)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ IM_ASSERT(buf != NULL && buf_size >= 0);+ IM_ASSERT(!((flags & ImGuiInputTextFlags_CallbackHistory) && (flags & ImGuiInputTextFlags_Multiline))); // Can't use both together (they both use up/down keys)+ IM_ASSERT(!((flags & ImGuiInputTextFlags_CallbackCompletion) && (flags & ImGuiInputTextFlags_AllowTabInput))); // Can't use both together (they both use tab key)+ IM_ASSERT(!((flags & ImGuiInputTextFlags_ElideLeft) && (flags & ImGuiInputTextFlags_Multiline))); // Multiline does not work with left-trimming+ IM_ASSERT((flags & ImGuiInputTextFlags_WordWrap) == 0 || (flags & ImGuiInputTextFlags_Password) == 0); // WordWrap does not work with Password mode.+ IM_ASSERT((flags & ImGuiInputTextFlags_WordWrap) == 0 || (flags & ImGuiInputTextFlags_Multiline) != 0); // WordWrap does not work in single-line mode.++ ImGuiContext& g = *GImGui;+ ImGuiIO& io = g.IO;+ const ImGuiStyle& style = g.Style;+ // BUI: text fields keep their text UI_TEXT_MARGIN_X (0.4 widget units) from the edge, as+ // Blender's (the frame size does not depend on it); restored on every return+ struct BuiRestorePadX { float* P; float V; ~BuiRestorePadX() { *P = V; } } bui_pad_x = { &g.Style.FramePadding.x, g.Style.FramePadding.x };+ if (BuiOn() && !(flags & ImGuiInputTextFlags_Multiline))+ g.Style.FramePadding.x = IM_ROUND(0.4f * IM_ROUND(GetFrameHeight()));++ const bool RENDER_SELECTION_WHEN_INACTIVE = false;+ const bool is_multiline = (flags & ImGuiInputTextFlags_Multiline) != 0;++ if (is_multiline) // Open group before calling GetID() because groups tracks id created within their scope (including the scrollbar)+ BeginGroup();+ const ImGuiID id = window->GetID(label);+ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);+ const ImVec2 frame_size = CalcItemSize(size_arg, CalcItemWidth(), (is_multiline ? g.FontSize * 8.0f : label_size.y) + style.FramePadding.y * 2.0f); // Arbitrary default of 8 lines high for multi-line+ const ImVec2 total_size = ImVec2(frame_size.x + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), frame_size.y);++ const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);+ const ImRect total_bb(frame_bb.Min, frame_bb.Min + total_size);++ ImGuiWindow* draw_window = window;+ ImVec2 inner_size = frame_size;+ ImGuiLastItemData item_data_backup;+ if (is_multiline)+ {+ ImVec2 backup_pos = window->DC.CursorPos;+ ItemSize(total_bb, style.FramePadding.y);+ bool no_clip = (g.InputTextDeactivatedState.ID == id) || (g.ActiveId == id) || (id == g.NavActivateId); // Mimic some of ItemAdd() logic + add InputTextDeactivatedState.ID check.+ if (!ItemAdd(total_bb, id, &frame_bb, ImGuiItemFlags_Inputable) && !no_clip)+ {+ EndGroup();+ return false;+ }+ item_data_backup = g.LastItemData;+ window->DC.CursorPos = backup_pos;++ // Prevent NavActivation from explicit Tabbing when our widget accepts Tab inputs: this allows cycling through widgets without stopping.+ if (g.NavActivateId == id && (g.NavActivateFlags & ImGuiActivateFlags_FromTabbing) && !(g.NavActivateFlags & ImGuiActivateFlags_FromFocusApi) && (flags & ImGuiInputTextFlags_AllowTabInput))+ g.NavActivateId = 0;++ // Prevent NavActivate reactivating in BeginChild() when we are already active.+ const ImGuiID backup_activate_id = g.NavActivateId;+ if (g.ActiveId == id) // Prevent reactivation+ g.NavActivateId = 0;++ // We reproduce the contents of BeginChildFrame() in order to provide 'label' so our window internal data are easier to read/debug.+ PushStyleColor(ImGuiCol_ChildBg, style.Colors[ImGuiCol_FrameBg]);+ PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);+ PushStyleVar(ImGuiStyleVar_ChildBorderSize, style.FrameBorderSize);+ PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0)); // Ensure no clip rect so mouse hover can reach FramePadding edges+ bool child_visible = BeginChildEx(label, id, frame_bb.GetSize(), ImGuiChildFlags_Borders, ImGuiWindowFlags_NoMove);+ g.NavActivateId = backup_activate_id;+ PopStyleVar(3);+ PopStyleColor();+ if (!child_visible && !no_clip)+ {+ EndChild();+ EndGroup();+ return false;+ }+ draw_window = g.CurrentWindow; // Child window+ if (BuiOn()) // BUI: Blender text field backdrop for the multi-line field+ BuiWindowBack(BK_WIDGET_TEXT, g.ActiveId == id ? BK_WS_EDITING : 0);+ draw_window->DC.NavLayersActiveMaskNext |= (1 << draw_window->DC.NavLayerCurrent); // This is to ensure that EndChild() will display a navigation highlight so we can "enter" into it.+ draw_window->DC.CursorPos += style.FramePadding;+ inner_size.x -= draw_window->ScrollbarSizes.x;++ // FIXME: Could this be a ImGuiChildFlags to affect the SetLastItemDataForWindow() call?+ g.LastItemData.ID = id;+ g.LastItemData.ItemFlags = item_data_backup.ItemFlags;+ g.LastItemData.StatusFlags = item_data_backup.StatusFlags;+ }+ else+ {+ // Support for internal ImGuiInputTextFlags_MergedItem flag, which could be redesigned as an ItemFlags if needed (with test performed in ItemAdd)+ ItemSize(total_bb, style.FramePadding.y);+ if (!(flags & ImGuiInputTextFlags_TempInput))+ if (!ItemAdd(total_bb, id, &frame_bb, ImGuiItemFlags_Inputable))+ return false;+ }++ // Ensure mouse cursor is set even after switching to keyboard/gamepad mode. May generalize further? (#6417)+ bool hovered = ItemHoverable(frame_bb, id, g.LastItemData.ItemFlags | ImGuiItemFlags_NoNavDisableMouseHover);+ if (hovered)+ SetMouseCursor(ImGuiMouseCursor_TextInput);+ if (hovered && g.NavHighlightItemUnderNav)+ hovered = false;++ // We are only allowed to access the state if we are already the active widget.+ ImGuiInputTextState* state = GetInputTextState(id);++ if (g.LastItemData.ItemFlags & ImGuiItemFlags_ReadOnly)+ flags |= ImGuiInputTextFlags_ReadOnly;+ const bool is_readonly = (flags & ImGuiInputTextFlags_ReadOnly) != 0;+ const bool is_password = (flags & ImGuiInputTextFlags_Password) != 0;+ const bool is_undoable = (flags & ImGuiInputTextFlags_NoUndoRedo) == 0;+ const bool is_resizable = (flags & ImGuiInputTextFlags_CallbackResize) != 0;+ const bool is_mixed = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;+ if (is_resizable)+ IM_ASSERT(callback != NULL); // Must provide a callback if you set the ImGuiInputTextFlags_CallbackResize flag!++ // Word-wrapping: enforcing a fixed width not altered by vertical scrollbar makes things easier, notably to track cursor reliably and avoid one-frame glitches.+ // Instead of using ImGuiWindowFlags_AlwaysVerticalScrollbar we account for that space if the scrollbar is not visible.+ const bool is_wordwrap = (flags & ImGuiInputTextFlags_WordWrap) != 0;+ float wrap_width = 0.0f;+ if (is_wordwrap)+ wrap_width = ImMax(1.0f, GetContentRegionAvail().x + (draw_window->ScrollbarY ? 0.0f : -g.Style.ScrollbarSize));++ const bool user_clicked = hovered && io.MouseClicked[0];+ const bool input_requested_by_nav = (g.ActiveId != id) && (g.NavActivateId == id);+ const bool input_requested_by_reactivate = (g.InputTextReactivateId == id); // for io.ConfigInputTextEnterKeepActive+ const bool input_requested_by_user = (user_clicked) || (g.ActiveId == 0 && (flags & ImGuiInputTextFlags_TempInput) && g.InputTextDeactivatedState.ID != id);+ const ImGuiID scrollbar_id = (is_multiline && state != NULL) ? GetWindowScrollbarID(draw_window, ImGuiAxis_Y) : 0;+ const bool user_scroll_finish = is_multiline && state != NULL && g.ActiveId == 0 && g.ActiveIdPreviousFrame == scrollbar_id;+ const bool user_scroll_active = is_multiline && state != NULL && g.ActiveId == scrollbar_id;+ bool clear_active_id = false;+ bool select_all = false;++ float scroll_y = is_multiline ? draw_window->Scroll.y : FLT_MAX;++ const bool init_reload_from_user_buf = (state != NULL && state->WantReloadUserBuf);+ const bool init_changed_specs_multiline = (state != NULL && (state->Stb->single_line != !is_multiline)); // state != NULL means its our state.+ const bool init_changed_specs_readonly = (state != NULL && ((state->Flags ^ flags) & ImGuiInputTextFlags_ReadOnly)); // state != NULL means its our state.+ const bool init_make_active = (input_requested_by_user || input_requested_by_nav || input_requested_by_reactivate || user_scroll_finish);+ if (init_reload_from_user_buf)+ {+ int new_len = (int)ImStrlen(buf);+ IM_ASSERT(new_len + 1 <= buf_size && "Is your input buffer properly zero-terminated?");+ state->WantReloadUserBuf = false;+ InputTextReconcileUndoState(state, state->TextA.Data, state->TextLen, buf, new_len);+ state->TextA.resize(buf_size + 1); // we use +1 to make sure that .Data is always pointing to at least an empty string.+ state->TextLen = new_len;+ memcpy(state->TextA.Data, buf, state->TextLen + 1);+ state->Stb->select_start = state->ReloadSelectionStart;+ state->Stb->cursor = state->Stb->select_end = state->ReloadSelectionEnd; // will be clamped to bounds below+ }+ else if ((init_make_active && g.ActiveId != id) || init_changed_specs_multiline || init_changed_specs_readonly)+ {+ // Access state even if we don't own it yet.+ state = &g.InputTextState;+ state->CursorAnimReset();++ // Backup state of deactivating item so they'll have a chance to do a write to output buffer on the same frame they report IsItemDeactivatedAfterEdit (#4714)+ if (state->ID != id && state->ID == g.ActiveId && (init_make_active && g.ActiveId != id)) //-V560+ InputTextDeactivateHook(state->ID); // <-- this is essentially an earlier call to what SetActiveID() would do below.++ // Take a copy of the initial buffer value.+ // From the moment we focused we are normally ignoring the content of 'buf' (unless we are in read-only mode)+ const int buf_len = (int)ImStrlen(buf);+ IM_ASSERT(((buf_len + 1 <= buf_size) || (buf_len == 0 && buf_size == 0)) && "Is your input buffer properly zero-terminated?");+ if (!user_scroll_finish)+ {+ state->TextToRevertTo.resize(buf_len + 1); // UTF-8. we use +1 to make sure that .Data is always pointing to at least an empty string.+ memcpy(state->TextToRevertTo.Data, buf, buf_len + 1);+ }++ // Preserve cursor position and undo/redo stack if we come back to same widget+ // FIXME: Since we reworked this on 2022/06, may want to differentiate recycle_cursor vs recycle_undostate?+ bool recycle_state = (state->ID == id && !init_changed_specs_multiline);+ if (recycle_state && !init_changed_specs_readonly && (state->TextLen != buf_len || (state->TextA.Data == NULL || strncmp(state->TextA.Data, buf, buf_len) != 0)))+ recycle_state = false;++ // Start edition+ state->ID = id;+ state->TextLen = buf_len;+ state->EditedBefore = false;+ if (!is_readonly)+ {+ state->TextA.resize(buf_size + 1); // we use +1 to make sure that .Data is always pointing to at least an empty string.+ memcpy(state->TextA.Data, buf, state->TextLen + 1);+ }++ // Find initial scroll position for right alignment+ state->Scroll = ImVec2(0.0f, 0.0f);+ if (flags & ImGuiInputTextFlags_ElideLeft)+ state->Scroll.x += ImMax(0.0f, CalcTextSize(buf).x - frame_size.x + style.FramePadding.x * 2.0f);++ // Recycle existing cursor/selection/undo stack but clamp position+ // Note a single mouse click will override the cursor/position immediately by calling stb_textedit_click handler.+ if (!recycle_state)+ stb_textedit_initialize_state(state->Stb, !is_multiline);++ if (!is_multiline)+ {+ if ((flags & ImGuiInputTextFlags_AutoSelectAll) || is_mixed)+ select_all = true;+ if (input_requested_by_nav && (!recycle_state || !(g.NavActivateFlags & ImGuiActivateFlags_TryToPreserveState)))+ select_all = true;+ if (user_clicked && io.KeyCtrl)+ select_all = true;+ }++ if (flags & ImGuiInputTextFlags_AlwaysOverwrite)+ state->Stb->insert_mode = 1; // stb field name is indeed incorrect (see #2863)+ }++ const bool is_osx = io.ConfigMacOSXBehaviors;+ if (init_make_active && g.ActiveId != id)+ {+ IM_ASSERT(state && state->ID == id);+ SetActiveID(id, window);+ SetFocusID(id, window);+ FocusWindow(window);+ if (input_requested_by_nav)+ SetNavCursorVisibleAfterMove();+ }+ if (g.ActiveId == id)+ {+ // Declare some inputs, the other are registered and polled via Shortcut() routing system.+ // FIXME: The reason we don't use Shortcut() is we would need a routing flag to specify multiple mods, or to all mods combination into individual shortcuts.+ const ImGuiKey always_owned_keys[] = { ImGuiKey_LeftArrow, ImGuiKey_RightArrow, ImGuiKey_Delete, ImGuiKey_Backspace, ImGuiKey_Home, ImGuiKey_End };+ for (ImGuiKey key : always_owned_keys)+ SetKeyOwner(key, id);+ if (user_clicked)+ SetKeyOwner(ImGuiKey_MouseLeft, id);+ g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Left) | (1 << ImGuiDir_Right);+ if (is_multiline || (flags & ImGuiInputTextFlags_CallbackHistory))+ {+ g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Up) | (1 << ImGuiDir_Down);+ SetKeyOwner(ImGuiKey_UpArrow, id);+ SetKeyOwner(ImGuiKey_DownArrow, id);+ }+ if (is_multiline)+ {+ SetKeyOwner(ImGuiKey_PageUp, id);+ SetKeyOwner(ImGuiKey_PageDown, id);+ }+ // FIXME: May be a problem to always steal Alt on OSX, would ideally still allow an uninterrupted Alt down-up to toggle menu+ if (is_osx)+ SetKeyOwner(ImGuiMod_Alt, id);++ // Expose scroll in a manner that is agnostic to us using a child window+ if (is_multiline && state != NULL)+ state->Scroll.y = draw_window->Scroll.y;++ // Read-only mode always ever read from source buffer. Refresh TextLen when active.+ if (is_readonly && state != NULL)+ state->TextLen = (int)ImStrlen(buf);+ if (state != NULL)+ state->CursorClamp();+ //if (is_readonly && state != NULL)+ // state->TextA.clear(); // Uncomment to facilitate debugging, but we otherwise prefer to keep/amortize th allocation.+ }+ if (state != NULL)+ state->TextSrc = is_readonly ? buf : state->TextA.Data;++ // We have an edge case if ActiveId was set through another widget (e.g. widget being swapped), clear id immediately (don't wait until the end of the function)+ if (g.ActiveId == id && state == NULL)+ ClearActiveID();++ // Release focus when we click outside+ if (g.ActiveId == id && io.MouseClicked[0] && !init_make_active) //-V560+ clear_active_id = true;++ // Lock the decision of whether we are going to take the path displaying the cursor or selection+ bool render_cursor = (g.ActiveId == id) || (state && user_scroll_active);+ bool render_selection = state && (state->HasSelection() || select_all) && (RENDER_SELECTION_WHEN_INACTIVE || render_cursor);+ bool value_changed = false;+ bool validated = false;++ // Select the buffer to render.+ const bool buf_display_from_state = (render_cursor || render_selection || g.ActiveId == id) && !is_readonly && state;+ bool is_displaying_hint = (hint != NULL && (buf_display_from_state ? state->TextSrc : buf)[0] == 0) && !is_mixed;++ // Password pushes a temporary font with only a fallback glyph+ if (is_password && !is_displaying_hint)+ PushPasswordFont();++ if (state != NULL && state->ID == id)+ {+ state->Flags = flags;+ state->EditedThisFrame = state->ValidatedThisFrame = false;+ //state->LastFrameActive = g.FrameCount;++ // Word-wrapping: attempt to keep cursor in view while resizing frame/parent (FIXME-WORDWRAP: would be better to preserve same relative offset)+ if (is_wordwrap && state->WrapWidth != wrap_width)+ {+ state->CursorCenterY = true;+ state->WrapWidth = wrap_width;+ render_cursor = true;+ }+ }++ // Process mouse inputs and character inputs+ if (g.ActiveId == id)+ {+ IM_ASSERT(state != NULL);+ state->BufCapacity = buf_size;+ state->WrapWidth = wrap_width;++ // Although we are active we don't prevent mouse from hovering other elements unless we are interacting right now with the widget.+ // Down the line we should have a cleaner library-wide concept of Selected vs Active.+ g.ActiveIdAllowOverlap = !io.MouseDown[0];++ // Edit in progress+ const float mouse_x = (io.MousePos.x - frame_bb.Min.x - style.FramePadding.x) + state->Scroll.x;+ const float mouse_y = (is_multiline ? (io.MousePos.y - draw_window->DC.CursorPos.y) : (g.FontSize * 0.5f));++ if (select_all)+ {+ state->SelectAll();+ state->SelectedAllMouseLock = true;+ }+ else if (hovered && io.MouseClickedCount[0] >= 2 && !io.KeyShift)+ {+ stb_textedit_click(state, state->Stb, mouse_x, mouse_y);+ const int multiclick_count = (io.MouseClickedCount[0] - 2);+ if ((multiclick_count % 2) == 0)+ {+ // Double-click: Select word+ // We always use the "Mac" word advance for double-click select vs Ctrl+Right which use the platform dependent variant:+ // FIXME: There are likely many ways to improve this behavior, but there's no "right" behavior (depends on use-case, software, OS)+ const bool is_bol = (state->Stb->cursor == 0) || ImStb::STB_TEXTEDIT_GETCHAR(state, state->Stb->cursor - 1) == '\n';+ if (STB_TEXT_HAS_SELECTION(state->Stb) || !is_bol)+ state->OnKeyPressed(STB_TEXTEDIT_K_WORDLEFT);+ //state->OnKeyPressed(STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT);+ if (!STB_TEXT_HAS_SELECTION(state->Stb))+ ImStb::stb_textedit_prep_selection_at_cursor(state->Stb);+ state->Stb->cursor = ImStb::STB_TEXTEDIT_MOVEWORDRIGHT_MAC(state, state->Stb->cursor);+ state->Stb->select_end = state->Stb->cursor;+ ImStb::stb_textedit_clamp(state, state->Stb);+ }+ else+ {+ // Triple-click: Select line+ const bool is_eol = ImStb::STB_TEXTEDIT_GETCHAR(state, state->Stb->cursor) == '\n';+ state->WrapWidth = 0.0f; // Temporarily disable wrapping so we use real line start.+ state->OnKeyPressed(STB_TEXTEDIT_K_LINESTART);+ state->OnKeyPressed(STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT);+ state->OnKeyPressed(STB_TEXTEDIT_K_RIGHT | STB_TEXTEDIT_K_SHIFT);+ state->WrapWidth = wrap_width;+ if (!is_eol && is_multiline)+ {+ ImSwap(state->Stb->select_start, state->Stb->select_end);+ state->Stb->cursor = state->Stb->select_end;+ }+ state->CursorFollow = false;+ }+ state->CursorAnimReset();+ }+ else if (io.MouseClicked[0] && !state->SelectedAllMouseLock)+ {+ if (hovered)+ {+ if (io.KeyShift)+ stb_textedit_drag(state, state->Stb, mouse_x, mouse_y);+ else+ stb_textedit_click(state, state->Stb, mouse_x, mouse_y);+ state->CursorAnimReset();+ }+ }+ else if (io.MouseDown[0] && !state->SelectedAllMouseLock && (io.MouseDelta.x != 0.0f || io.MouseDelta.y != 0.0f))+ {+ stb_textedit_drag(state, state->Stb, mouse_x, mouse_y);+ state->CursorAnimReset();+ state->CursorFollow = true;+ }+ if (state->SelectedAllMouseLock && !io.MouseDown[0])+ state->SelectedAllMouseLock = false;++ // We expect backends to emit a Tab key but some also emit a Tab character which we ignore (#2467, #1336)+ // (For Tab and Enter: Win32/SFML/Allegro are sending both keys and chars, GLFW and SDL are only sending keys. For Space they all send all threes)+ if ((flags & ImGuiInputTextFlags_AllowTabInput) && !is_readonly)+ {+ if (Shortcut(ImGuiKey_Tab, ImGuiInputFlags_Repeat, id))+ {+ unsigned int c = '\t'; // Insert TAB+ if (InputTextFilterCharacter(&g, state, &c, callback, callback_user_data))+ state->OnCharPressed(c);+ }+ // FIXME: Implement Shift+Tab+ /*+ if (Shortcut(ImGuiKey_Tab | ImGuiMod_Shift, ImGuiInputFlags_Repeat, id))+ {+ }+ */+ }++ // Process regular text input (before we check for Return because using some IME will effectively send a Return?)+ // We ignore Ctrl inputs, but need to allow Alt+Ctrl as some keyboards (e.g. German) use AltGR (which _is_ Alt+Ctrl) to input certain characters.+ const bool ignore_char_inputs = (io.KeyCtrl && !io.KeyAlt) || (is_osx && io.KeyCtrl);+ if (io.InputQueueCharacters.Size > 0)+ {+ if (!ignore_char_inputs && !is_readonly && !input_requested_by_nav)+ for (int n = 0; n < io.InputQueueCharacters.Size; n++)+ {+ // Insert character if they pass filtering+ unsigned int c = (unsigned int)io.InputQueueCharacters[n];+ if (c == '\t') // Skip Tab, see above.+ continue;+ if (InputTextFilterCharacter(&g, state, &c, callback, callback_user_data))+ state->OnCharPressed(c);+ }++ // Consume characters+ io.InputQueueCharacters.resize(0);+ }+ }++ // Process other shortcuts/key-presses+ bool revert_edit = false;+ if (g.ActiveId == id && !g.ActiveIdIsJustActivated && !clear_active_id)+ {+ IM_ASSERT(state != NULL);++ const int row_count_per_page = ImMax((int)((inner_size.y - style.FramePadding.y) / g.FontSize), 1);+ state->Stb->row_count_per_page = row_count_per_page;++ const int k_mask = (io.KeyShift ? STB_TEXTEDIT_K_SHIFT : 0);+ const bool is_wordmove_key_down = is_osx ? io.KeyAlt : io.KeyCtrl; // OS X style: Text editing cursor movement using Alt instead of Ctrl+ const bool is_startend_key_down = is_osx && io.KeyCtrl && !io.KeySuper && !io.KeyAlt; // OS X style: Line/Text Start and End using Cmd+Arrows instead of Home/End++ // Using Shortcut() with ImGuiInputFlags_RouteFocused (default policy) to allow routing operations for other code (e.g. calling window trying to use Ctrl+A and Ctrl+B: former would be handled by InputText)+ // Otherwise we could simply assume that we own the keys as we are active.+ const ImGuiInputFlags f_repeat = ImGuiInputFlags_Repeat;+ const bool is_cut = (Shortcut(ImGuiMod_Ctrl | ImGuiKey_X, f_repeat, id) || Shortcut(ImGuiMod_Shift | ImGuiKey_Delete, f_repeat, id)) && !is_readonly && !is_password && (!is_multiline || state->HasSelection());+ const bool is_copy = (Shortcut(ImGuiMod_Ctrl | ImGuiKey_C, 0, id) || Shortcut(ImGuiMod_Ctrl | ImGuiKey_Insert, 0, id)) && !is_password && (!is_multiline || state->HasSelection());+ const bool is_paste = (Shortcut(ImGuiMod_Ctrl | ImGuiKey_V, f_repeat, id) || Shortcut(ImGuiMod_Shift | ImGuiKey_Insert, f_repeat, id)) && !is_readonly;+ const bool is_undo = (Shortcut(ImGuiMod_Ctrl | ImGuiKey_Z, f_repeat, id)) && !is_readonly && is_undoable;+ const bool is_redo = (Shortcut(ImGuiMod_Ctrl | ImGuiKey_Y, f_repeat, id) || Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Z, f_repeat, id)) && !is_readonly && is_undoable;+ const bool is_select_all = Shortcut(ImGuiMod_Ctrl | ImGuiKey_A, 0, id);++ // We allow validate/cancel with Nav source (gamepad) to makes it easier to undo an accidental NavInput press with no keyboard wired, but otherwise it isn't very useful.+ const bool nav_gamepad_active = (io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) != 0 && (io.BackendFlags & ImGuiBackendFlags_HasGamepad) != 0;+ const bool is_enter = Shortcut(ImGuiKey_Enter, f_repeat, id) || Shortcut(ImGuiKey_KeypadEnter, f_repeat, id);+ const bool is_ctrl_enter = Shortcut(ImGuiMod_Ctrl | ImGuiKey_Enter, f_repeat, id) || Shortcut(ImGuiMod_Ctrl | ImGuiKey_KeypadEnter, f_repeat, id);+ const bool is_shift_enter = Shortcut(ImGuiMod_Shift | ImGuiKey_Enter, f_repeat, id) || Shortcut(ImGuiMod_Shift | ImGuiKey_KeypadEnter, f_repeat, id);+ const bool is_gamepad_validate = nav_gamepad_active && IsKeyPressed(ImGuiKey_NavGamepadActivate, false);+ const bool is_cancel = Shortcut(ImGuiKey_Escape, f_repeat, id) || (nav_gamepad_active && Shortcut(ImGuiKey_NavGamepadCancel, f_repeat, id));++ // FIXME: Should use more Shortcut() and reduce IsKeyPressed()+SetKeyOwner(), but requires modifiers combination to be taken account of.+ // FIXME-OSX: Missing support for Alt(option)+Right/Left = go to end of line, or next line if already in end of line.+ if (IsKeyPressed(ImGuiKey_LeftArrow)) { state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_LINESTART : is_wordmove_key_down ? STB_TEXTEDIT_K_WORDLEFT : STB_TEXTEDIT_K_LEFT) | k_mask); }+ else if (IsKeyPressed(ImGuiKey_RightArrow)) { state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_LINEEND : is_wordmove_key_down ? STB_TEXTEDIT_K_WORDRIGHT : STB_TEXTEDIT_K_RIGHT) | k_mask); }+ else if (IsKeyPressed(ImGuiKey_UpArrow) && is_multiline) { if (io.KeyCtrl) SetScrollY(draw_window, ImMax(draw_window->Scroll.y - g.FontSize, 0.0f)); else state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_TEXTSTART : STB_TEXTEDIT_K_UP) | k_mask); }+ else if (IsKeyPressed(ImGuiKey_DownArrow) && is_multiline) { if (io.KeyCtrl) SetScrollY(draw_window, ImMin(draw_window->Scroll.y + g.FontSize, GetScrollMaxY())); else state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_TEXTEND : STB_TEXTEDIT_K_DOWN) | k_mask); }+ else if (IsKeyPressed(ImGuiKey_PageUp) && is_multiline) { state->OnKeyPressed(STB_TEXTEDIT_K_PGUP | k_mask); scroll_y -= row_count_per_page * g.FontSize; }+ else if (IsKeyPressed(ImGuiKey_PageDown) && is_multiline) { state->OnKeyPressed(STB_TEXTEDIT_K_PGDOWN | k_mask); scroll_y += row_count_per_page * g.FontSize; }+ else if (IsKeyPressed(ImGuiKey_Home)) { state->OnKeyPressed(io.KeyCtrl ? STB_TEXTEDIT_K_TEXTSTART | k_mask : STB_TEXTEDIT_K_LINESTART | k_mask); }+ else if (IsKeyPressed(ImGuiKey_End)) { state->OnKeyPressed(io.KeyCtrl ? STB_TEXTEDIT_K_TEXTEND | k_mask : STB_TEXTEDIT_K_LINEEND | k_mask); }+ else if (IsKeyPressed(ImGuiKey_Delete) && !is_readonly && !is_cut)+ {+ if (!state->HasSelection())+ {+ // OSX doesn't seem to have Super+Delete to delete until end-of-line, so we don't emulate that (as opposed to Super+Backspace)+ if (is_wordmove_key_down)+ state->OnKeyPressed(STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT);+ }+ state->OnKeyPressed(STB_TEXTEDIT_K_DELETE | k_mask);+ }+ else if (IsKeyPressed(ImGuiKey_Backspace) && !is_readonly)+ {+ if (!state->HasSelection())+ {+ if (is_wordmove_key_down)+ state->OnKeyPressed(STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT);+ else if (is_osx && io.KeyCtrl && !io.KeyAlt && !io.KeySuper)+ state->OnKeyPressed(STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT);+ }+ state->OnKeyPressed(STB_TEXTEDIT_K_BACKSPACE | k_mask);+ }+ else if (is_enter || is_ctrl_enter || is_shift_enter || is_gamepad_validate)+ {+ // Determine if we turn Enter into a \n character+ bool ctrl_enter_for_new_line = (flags & ImGuiInputTextFlags_CtrlEnterForNewLine) != 0;+ bool is_new_line = is_multiline && !is_gamepad_validate && (is_shift_enter || (is_enter && !ctrl_enter_for_new_line) || (is_ctrl_enter && ctrl_enter_for_new_line));+ if (!is_new_line)+ {+ validated = clear_active_id = true;+ if (io.ConfigInputTextEnterKeepActive && !is_multiline && !is_ctrl_enter && !is_shift_enter)+ {+ // Queue reactivation, so that e.g. IsItemDeactivatedAfterEdit() will work. (#9001)+ state->SelectAll(); // No need to scroll+ g.InputTextReactivateId = id; // Mark for reactivation on next frame+ }+ }+ else if (!is_readonly)+ {+ // Insert new line+ unsigned int c = '\n';+ if (InputTextFilterCharacter(&g, state, &c, callback, callback_user_data))+ state->OnCharPressed(c);+ }+ }+ else if (is_cancel)+ {+ if (flags & ImGuiInputTextFlags_EscapeClearsAll)+ {+ if (state->TextSrc[0] != 0)+ {+ revert_edit = true;+ }+ else+ {+ render_cursor = render_selection = false;+ clear_active_id = true;+ }+ }+ else+ {+ clear_active_id = revert_edit = true;+ render_cursor = render_selection = false;+ }+ }+ else if (is_undo || is_redo)+ {+ state->OnKeyPressed(is_undo ? STB_TEXTEDIT_K_UNDO : STB_TEXTEDIT_K_REDO);+ state->ClearSelection();+ }+ else if (is_select_all)+ {+ state->SelectAll();+ state->CursorFollow = true;+ }+ else if (is_cut || is_copy)+ {+ // Cut, Copy+ if (g.PlatformIO.Platform_SetClipboardTextFn != NULL)+ {+ // SetClipboardText() only takes null terminated strings + state->TextSrc may point to read-only user buffer, so we need to make a copy.+ const int ib = state->HasSelection() ? ImMin(state->Stb->select_start, state->Stb->select_end) : 0;+ const int ie = state->HasSelection() ? ImMax(state->Stb->select_start, state->Stb->select_end) : state->TextLen;+ g.TempBuffer.reserve(ie - ib + 1);+ memcpy(g.TempBuffer.Data, state->TextSrc + ib, ie - ib);+ g.TempBuffer.Data[ie - ib] = 0;+ SetClipboardText(g.TempBuffer.Data);+ }+ if (is_cut)+ {+ if (!state->HasSelection())+ state->SelectAll();+ state->CursorFollow = true;+ stb_textedit_cut(state, state->Stb);+ }+ }+ else if (is_paste)+ {+ if (const char* clipboard = GetClipboardText())+ {+ // Filter pasted buffer+ const int clipboard_len = (int)ImStrlen(clipboard);+ const char* clipboard_end = clipboard + clipboard_len;+ ImVector<char> clipboard_filtered;+ clipboard_filtered.reserve(clipboard_len + 1);+ for (const char* s = clipboard; *s != 0; )+ {+ unsigned int c;+ int in_len = ImTextCharFromUtf8(&c, s, clipboard_end);+ s += in_len;+ if (!InputTextFilterCharacter(&g, state, &c, callback, callback_user_data, true))+ continue;+ char c_utf8[5];+ ImTextCharToUtf8(c_utf8, c);+ int out_len = (int)ImStrlen(c_utf8);+ clipboard_filtered.resize(clipboard_filtered.Size + out_len);+ memcpy(clipboard_filtered.Data + clipboard_filtered.Size - out_len, c_utf8, out_len);+ }+ if (clipboard_filtered.Size > 0) // If everything was filtered, ignore the pasting operation+ {+ clipboard_filtered.push_back(0);+ stb_textedit_paste(state, state->Stb, clipboard_filtered.Data, clipboard_filtered.Size - 1);+ state->CursorFollow = true;+ }+ }+ }++ // Update render selection flag after events have been handled, so selection highlight can be displayed during the same frame.+ render_selection |= state->HasSelection() && (RENDER_SELECTION_WHEN_INACTIVE || render_cursor);+ }++ // Process revert and user callbacks+ const char* apply_new_text = NULL;+ int apply_new_text_length = 0;+ if (g.ActiveId == id)+ {+ IM_ASSERT(state != NULL);+ if (revert_edit && !is_readonly)+ {+ if (flags & ImGuiInputTextFlags_EscapeClearsAll)+ {+ // Clear input+ IM_ASSERT(state->TextSrc[0] != 0);+ apply_new_text = "";+ apply_new_text_length = 0;+ value_changed = true;+ char empty_string = 0;+ stb_textedit_replace(state, state->Stb, &empty_string, 0);+ }+ else if (strcmp(state->TextSrc, state->TextToRevertTo.Data) != 0)+ {+ apply_new_text = state->TextToRevertTo.Data;+ apply_new_text_length = state->TextToRevertTo.Size - 1;++ // Restore initial value. Only return true if restoring to the initial value changes the current buffer contents.+ // Push records into the undo stack so we can Ctrl+Z the revert operation itself+ value_changed = true;+ stb_textedit_replace(state, state->Stb, state->TextToRevertTo.Data, state->TextToRevertTo.Size - 1);+ }+ }++ // User callback+ if ((flags & (ImGuiInputTextFlags_CallbackCompletion | ImGuiInputTextFlags_CallbackHistory | ImGuiInputTextFlags_CallbackEdit | ImGuiInputTextFlags_CallbackAlways)) != 0)+ {+ IM_ASSERT(callback != NULL);++ // The reason we specify the usage semantic (Completion/History) is that Completion needs to disable keyboard TABBING at the moment.+ ImGuiInputTextFlags event_flag = 0;+ ImGuiKey event_key = ImGuiKey_None;+ if ((flags & ImGuiInputTextFlags_CallbackCompletion) != 0 && Shortcut(ImGuiKey_Tab, 0, id))+ {+ event_flag = ImGuiInputTextFlags_CallbackCompletion;+ event_key = ImGuiKey_Tab;+ }+ else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressed(ImGuiKey_UpArrow))+ {+ event_flag = ImGuiInputTextFlags_CallbackHistory;+ event_key = ImGuiKey_UpArrow;+ }+ else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressed(ImGuiKey_DownArrow))+ {+ event_flag = ImGuiInputTextFlags_CallbackHistory;+ event_key = ImGuiKey_DownArrow;+ }+ else if ((flags & ImGuiInputTextFlags_CallbackEdit) && state->EditedThisFrame)+ {+ event_flag = ImGuiInputTextFlags_CallbackEdit;+ }+ else if (flags & ImGuiInputTextFlags_CallbackAlways)+ {+ event_flag = ImGuiInputTextFlags_CallbackAlways;+ }++ if (event_flag)+ {+ ImGuiInputTextCallbackData callback_data;+ callback_data.Ctx = &g;+ callback_data.ID = id;+ callback_data.Flags = flags;+ callback_data.EventFlag = event_flag;+ callback_data.EventActivated = (g.ActiveId == state->ID && g.ActiveIdIsJustActivated);+ callback_data.UserData = callback_user_data;++ // FIXME-OPT: Undo stack reconcile needs a backup of the data until we rework API, see #7925+ char* callback_buf = is_readonly ? buf : state->TextA.Data;+ IM_ASSERT(callback_buf == state->TextSrc);+ state->CallbackTextBackup.resize(state->TextLen + 1);+ memcpy(state->CallbackTextBackup.Data, callback_buf, state->TextLen + 1);++ callback_data.EventKey = event_key;+ callback_data.Buf = callback_buf;+ callback_data.BufTextLen = state->TextLen;+ callback_data.BufSize = state->BufCapacity;+ callback_data.BufDirty = false;+ callback_data.CursorPos = state->Stb->cursor;+ callback_data.SelectionStart = state->Stb->select_start;+ callback_data.SelectionEnd = state->Stb->select_end;++ // Call user code+ callback(&callback_data);++ // Read back what user may have modified+ callback_buf = is_readonly ? buf : state->TextA.Data; // Pointer may have been invalidated by a resize callback+ IM_ASSERT(callback_data.Buf == callback_buf); // Invalid to modify those fields+ IM_ASSERT(callback_data.BufSize == state->BufCapacity);+ IM_ASSERT(callback_data.Flags == flags);+ if (callback_data.BufDirty || callback_data.CursorPos != state->Stb->cursor)+ state->CursorFollow = true;+ state->Stb->cursor = ImClamp(callback_data.CursorPos, 0, callback_data.BufTextLen);+ state->Stb->select_start = ImClamp(callback_data.SelectionStart, 0, callback_data.BufTextLen);+ state->Stb->select_end = ImClamp(callback_data.SelectionEnd, 0, callback_data.BufTextLen);+ if (callback_data.BufDirty)+ {+ // Callback may update buffer and thus set buf_dirty even in read-only mode.+ IM_ASSERT(callback_data.BufTextLen == (int)ImStrlen(callback_data.Buf)); // You need to maintain BufTextLen if you change the text!+ InputTextReconcileUndoState(state, state->CallbackTextBackup.Data, state->CallbackTextBackup.Size - 1, callback_data.Buf, callback_data.BufTextLen);+ state->TextLen = callback_data.BufTextLen; // Assume correct length and valid UTF-8 from user, saves us an extra strlen()+ state->EditedBefore = state->EditedThisFrame = true;+ state->CursorAnimReset();+ }+ }+ }++ // Write back result string if modified.+ // FIXME-OPT: Could mark dirty state from the stb_textedit callbacks+ if (!is_readonly)+ {+ if (g.LastItemData.ItemFlags & ImGuiItemFlags_LiveEditOnInputText)+ {+ // Apply when modified+ if (strcmp(state->TextSrc, buf) != 0 || (is_mixed && (state->EditedThisFrame || validated)))+ {+ apply_new_text = state->TextSrc;+ apply_new_text_length = state->TextLen;+ value_changed = true;+ }+ }+ else+ {+ // Apply on validation/deactivation, otherwise cancel out previous apply attempts (e.g. revert)+ value_changed = (validated || clear_active_id || revert_edit) && (strcmp(state->TextSrc, buf) != 0 || (is_mixed && validated));+ apply_new_text = value_changed ? state->TextSrc : NULL;+ apply_new_text_length = value_changed ? state->TextLen : 0;+ }+ }+ }++ // Handle reapplying final data on deactivation (see InputTextDeactivateHook() for details)+ // This is used when e.g. losing focus or tabbing out into another InputText() which may already be using the temp buffer.+ if (g.InputTextDeactivatedState.ID == id)+ {+ // The state only exists after an Edit. IsItemDeactivatedAfterEdit() is not valid in every code path (see "widgets_inputtext_status_noliveedit" test).+ if ((g.ActiveId != id && IsItemDeactivated()) || (g.ActiveId == id && (flags & ImGuiInputTextFlags_TempInput)))+ if (!is_readonly && strcmp(g.InputTextDeactivatedState.TextA.Data, buf) != 0)+ {+ apply_new_text = g.InputTextDeactivatedState.TextA.Data;+ apply_new_text_length = g.InputTextDeactivatedState.TextA.Size - 1;+ value_changed = true;+ //IMGUI_DEBUG_LOG("InputText(): apply Deactivated data for 0x%08X: \"%.*s\".\n", id, apply_new_text_length, apply_new_text);+ }+ g.InputTextDeactivatedState.ID = 0;+ }++ // Write back result to user buffer. This can currently only happen when (g.ActiveId == id) or when just deactivated.+ // - As soon as the InputText() is active, our stored in-widget value gets priority over any underlying modification of the user buffer.+ // - Make sure we always reapply the live buffer back to the input/user buffer before clearing ActiveId, even thought strictly speaking+ // it was not modified on this frame. This allows the user to use InputText() without maintaining any user-side storage.+ // (PS: if you use this property together with ImGuiInputTextFlags_CallbackResize, you are at the risk of recreating a temporary+ // allocated/string object every frame. Which in the grand scheme of scheme is nothing, but isn't dear imgui vibe).+ if (apply_new_text != NULL)+ {+ IM_ASSERT(apply_new_text_length >= 0);+ if (is_resizable)+ {+ ImGuiInputTextCallbackData callback_data;+ callback_data.Ctx = &g;+ callback_data.ID = id;+ callback_data.Flags = flags;+ callback_data.EventFlag = ImGuiInputTextFlags_CallbackResize;+ callback_data.EventActivated = (state != NULL && g.ActiveId == state->ID && g.ActiveIdIsJustActivated);+ callback_data.Buf = buf;+ callback_data.BufTextLen = apply_new_text_length;+ callback_data.BufSize = ImMax(buf_size, apply_new_text_length + 1);+ callback_data.UserData = callback_user_data;+ callback(&callback_data);+ buf = callback_data.Buf;+ buf_size = callback_data.BufSize;+ apply_new_text_length = ImMin(callback_data.BufTextLen, buf_size - 1);+ IM_ASSERT(apply_new_text_length <= buf_size);+ }+ //IMGUI_DEBUG_PRINT("InputText(\"%s\"): apply_new_text length %d\n", label, apply_new_text_length);++ // If the underlying buffer resize was denied or not carried to the next frame, apply_new_text_length+1 may be >= buf_size.+ ImStrncpy(buf, apply_new_text, ImMin(apply_new_text_length + 1, buf_size));+ }++ // Release active ID at the end of the function (so e.g. pressing Return still does a final application of the value)+ // Otherwise request text input ahead for next frame.+ if (g.ActiveId == id && clear_active_id)+ {+ state->EditedBefore = false; // Data already applied: avoid InputTextDeactivateHook() taking a record now or later if same id is activated again without editing.+ ClearActiveID();+ }++ // Render frame+ if (!is_multiline && BuiOn()) // BUI: Blender text field (text_draw: wcol_text; typing: text_sel look)+ {+ RenderNavCursor(frame_bb, id);+ BuiEmit(BuiWidget(BK_WIDGET_TEXT, frame_bb, g.ActiveId == id ? BK_WS_EDITING : hovered ? BK_WS_HOVER : 0));+ }+ else if (!is_multiline) // BUI+ {+ RenderNavCursor(frame_bb, id);+ RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);+ }++ ImVec2 draw_pos = is_multiline ? draw_window->DC.CursorPos : frame_bb.Min + style.FramePadding;+ ImRect clip_rect(frame_bb.Min.x, frame_bb.Min.y, frame_bb.Min.x + inner_size.x, frame_bb.Min.y + inner_size.y); // Not using frame_bb.Max because we have adjusted size+ if (is_multiline)+ clip_rect.ClipWith(draw_window->ClipRect);++ // Set upper limit of single-line InputTextEx() at 2 million characters strings. The current pathological worst case is a long line+ // without any carriage return, which would makes ImFont::RenderText() reserve too many vertices and probably crash. Avoid it altogether.+ // Note that we only use this limit on single-line InputText(), so a pathologically large line on a InputTextMultiline() would still crash.+ const int buf_display_max_length = 2 * 1024 * 1024;+ const char* buf_display = buf_display_from_state ? state->TextA.Data : buf; //-V595+ const char* buf_display_end = NULL; // We have specialized paths below for setting the length++ // Display hint when contents is empty+ // At this point we need to handle the possibility that a callback could have modified the underlying buffer (#8368)+ const bool new_is_displaying_hint = (hint != NULL && (buf_display_from_state ? state->TextA.Data : buf)[0] == 0) && !is_mixed;+ if (new_is_displaying_hint != is_displaying_hint)+ {+ if (is_password && !is_displaying_hint)+ PopPasswordFont();+ is_displaying_hint = new_is_displaying_hint;+ if (is_password && !is_displaying_hint)+ PushPasswordFont();+ }+ const bool is_displaying_mixed = is_mixed && g.ActiveId != id && apply_new_text == NULL;+ if (is_displaying_mixed && g.MixedValueLabel != NULL)+ {+ buf_display = g.MixedValueLabel;+ buf_display_end = buf_display + strlen(g.MixedValueLabel);+ render_cursor = render_selection = false;+ }+ else if (is_displaying_hint)+ {+ buf_display = hint;+ buf_display_end = buf_display + ImStrlen(buf_display);+ }+ else+ {+ if (render_cursor || render_selection || g.ActiveId == id)+ buf_display_end = buf_display + state->TextLen; //-V595+ else if (is_multiline && !is_wordwrap)+ buf_display_end = NULL; // Inactive multi-line: end of buffer will be output by InputTextLineIndexBuild() special strchr() path.+ else+ buf_display_end = buf_display + ImStrlen(buf_display);+ }++ // Calculate visibility+ int line_visible_n0 = 0, line_visible_n1 = 1;+ if (is_multiline)+ CalcClipRectVisibleItemsY(clip_rect, draw_pos, g.FontSize, &line_visible_n0, &line_visible_n1);++ // Build line index for easy data access (makes code below simpler and faster)+ ImGuiTextIndex* line_index = &g.InputTextLineIndex;+ line_index->Offsets.resize(0);+ int line_count = 1;+ if (is_multiline)+ {+ // If scrolling is expected to change build full index.+ // FIXME-OPT: Could append to index when new value of line_visible_n1 becomes bigger, see second call to CalcClipRectVisibleItemsY() below.+ bool will_scroll_y = state && ((state->CursorFollow && render_cursor) || (state->CursorCenterY && (render_cursor || render_selection)));+ line_count = InputTextLineIndexBuild(flags, line_index, buf_display, buf_display_end, wrap_width, will_scroll_y ? INT_MAX : line_visible_n1 + 1, buf_display_end ? NULL : &buf_display_end);+ }+ line_index->EndOffset = (int)(buf_display_end - buf_display);+ line_visible_n1 = ImMin(line_visible_n1, line_count);++ // Store text height (we don't need width)+ float text_size_y = line_count * g.FontSize;+ //GetForegroundDrawList()->AddRect(draw_pos + ImVec2(0, line_visible_n0 * g.FontSize), draw_pos + ImVec2(frame_size.x, line_visible_n1 * g.FontSize), IM_COL32(255, 0, 0, 255));++ // Calculate blinking cursor position+ const ImVec2 cursor_offset = render_cursor && state ? InputTextLineIndexGetPosOffset(g, state, line_index, buf_display, buf_display_end, state->Stb->cursor) : ImVec2(0.0f, 0.0f);+ ImVec2 draw_scroll;++ // Render text. We currently only render selection when the widget is active or while scrolling.+ const ImU32 text_col = GetColorU32(is_displaying_mixed ? ImGuiCol_TextMixedValue : is_displaying_hint ? ImGuiCol_TextDisabled : ImGuiCol_Text);+ if (render_cursor || render_selection)+ {+ // Render text (with cursor and selection)+ // This is going to be messy. We need to:+ // - Display the text (this alone can be more easily clipped)+ // - Handle scrolling, highlight selection, display cursor (those all requires some form of 1d->2d cursor position calculation)+ // - Measure text height (for scrollbar)+ // We are attempting to do most of that in **one main pass** to minimize the computation cost (non-negligible for large amount of text) + 2nd pass for selection rendering (we could merge them by an extra refactoring effort)+ // FIXME: This should occur on buf_display but we'd need to maintain cursor/select_start/select_end for UTF-8.+ IM_ASSERT(state != NULL);+ state->LineCount = line_count;++ // Scroll+ float new_scroll_y = scroll_y;+ if (render_cursor && state->CursorFollow)+ {+ // Horizontal scroll in chunks of quarter width+ if (!(flags & ImGuiInputTextFlags_NoHorizontalScroll))+ {+ const float scroll_increment_x = inner_size.x * 0.25f;+ const float visible_width = inner_size.x - style.FramePadding.x;+ if (cursor_offset.x < state->Scroll.x)+ state->Scroll.x = IM_TRUNC(ImMax(0.0f, cursor_offset.x - scroll_increment_x));+ else if (cursor_offset.x - visible_width >= state->Scroll.x)+ state->Scroll.x = IM_TRUNC(cursor_offset.x - visible_width + scroll_increment_x);+ }+ else+ {+ state->Scroll.x = 0.0f;+ }++ // Vertical scroll+ if (is_multiline)+ {+ // Test if cursor is vertically visible+ if (cursor_offset.y - g.FontSize < scroll_y)+ new_scroll_y = ImMax(0.0f, cursor_offset.y - g.FontSize);+ else if (cursor_offset.y - (inner_size.y - style.FramePadding.y * 2.0f) >= scroll_y)+ new_scroll_y = cursor_offset.y - inner_size.y + style.FramePadding.y * 2.0f;+ }+ state->CursorFollow = false;+ }+ if (state->CursorCenterY)+ {+ if (is_multiline)+ new_scroll_y = cursor_offset.y - g.FontSize - (inner_size.y * 0.5f - style.FramePadding.y);+ state->CursorCenterY = false;+ render_cursor = false;+ }+ if (new_scroll_y != scroll_y)+ {+ const float scroll_max_y = ImMax((text_size_y + style.FramePadding.y * 2.0f) - inner_size.y, 0.0f);+ scroll_y = ImClamp(new_scroll_y, 0.0f, scroll_max_y);+ draw_pos.y += (draw_window->Scroll.y - scroll_y); // Manipulate cursor pos immediately avoid a frame of lag+ draw_window->Scroll.y = scroll_y;+ CalcClipRectVisibleItemsY(clip_rect, draw_pos, g.FontSize, &line_visible_n0, &line_visible_n1);+ line_visible_n1 = ImMin(line_visible_n1, line_count);+ }++ // Draw selection+ draw_scroll.x = state->Scroll.x;+ if (render_selection)+ {+ const ImU32 bg_color = GetColorU32(ImGuiCol_TextSelectedBg, render_cursor ? 1.0f : 0.6f); // FIXME: current code flow mandate that render_cursor is always true here, we are leaving the transparent one for tests.+ const float bg_offy_up = is_multiline ? 0.0f : -1.0f; // FIXME-DPI: those offsets should be part of the style? they don't play so well with multi-line selection.+ const float bg_offy_dn = is_multiline ? 0.0f : 2.0f;+ const float bg_eol_width = IM_TRUNC(g.FontBaked->GetCharAdvance((ImWchar)' ') * 0.50f); // So we can see selected empty lines++ const char* text_selected_begin = buf_display + ImMin(state->Stb->select_start, state->Stb->select_end);+ const char* text_selected_end = buf_display + ImMax(state->Stb->select_start, state->Stb->select_end);+ for (int line_n = line_visible_n0; line_n < line_visible_n1; line_n++)+ {+ const char* p = line_index->get_line_begin(buf_display, line_n);+ const char* p_eol = line_index->get_line_end(buf_display, line_n);+ const bool p_eol_is_wrap = (p_eol < buf_display_end && *p_eol != '\n');+ if (p_eol_is_wrap)+ p_eol++;+ const char* line_selected_begin = (text_selected_begin > p) ? text_selected_begin : p;+ const char* line_selected_end = (text_selected_end < p_eol) ? text_selected_end : p_eol;++ float rect_width = 0.0f;+ if (line_selected_begin < line_selected_end)+ rect_width += CalcTextSize(line_selected_begin, line_selected_end).x;+ if (text_selected_begin <= p_eol && text_selected_end > p_eol && !p_eol_is_wrap)+ rect_width += bg_eol_width; // So we can see selected empty lines+ if (rect_width == 0.0f)+ continue;++ ImRect rect;+ rect.Min.x = draw_pos.x - draw_scroll.x + CalcTextSize(p, line_selected_begin).x;+ rect.Min.y = draw_pos.y - draw_scroll.y + line_n * g.FontSize;+ rect.Max.x = rect.Min.x + rect_width;+ rect.Max.y = rect.Min.y + bg_offy_dn + g.FontSize;+ rect.Min.y += bg_offy_up;+ rect.ClipWith(clip_rect);+ draw_window->DrawList->AddRectFilled(rect.Min, rect.Max, bg_color);+ }+ }+ }++ // Find render position for right alignment (single-line only)+ if (g.ActiveId != id && (flags & ImGuiInputTextFlags_ElideLeft) && !render_cursor && !render_selection)+ draw_pos.x = ImMin(draw_pos.x, frame_bb.Max.x - CalcTextSize(buf_display, NULL).x - style.FramePadding.x);+ //draw_scroll.x = state->Scroll.x; // Preserve scroll when inactive?++ // Render text+ if (BuiTextOk() && !is_multiline && g.ActiveId != id && !render_cursor && !render_selection && (text_col & IM_COL32_A_MASK) && (line_visible_n0 < line_visible_n1))+ {+ // BUI: a field not being edited shows its text with BUI's text, as the kit's text fields;+ // while typing, ImGui's own glyphs (its cursor and selection are measured with them)+ const ImRect bui_clip(clip_rect.Min, clip_rect.Max);+ BuiTextLine(draw_window->DrawList, draw_pos - draw_scroll, line_index->get_line_begin(buf_display, line_visible_n0), line_index->get_line_end(buf_display, line_visible_n1 - 1), &bui_clip, text_col);+ }+ else if ((is_multiline || (buf_display_end - buf_display) < buf_display_max_length) && (text_col & IM_COL32_A_MASK) && (line_visible_n0 < line_visible_n1)) // BUI: else+ (g.Font->RenderText)(draw_window->DrawList, g.FontSize, // BUI: parenthesized, not the RenderText macro+ draw_pos - draw_scroll + ImVec2(0.0f, line_visible_n0 * g.FontSize),+ text_col, clip_rect.AsVec4(),+ line_index->get_line_begin(buf_display, line_visible_n0),+ line_index->get_line_end(buf_display, line_visible_n1 - 1),+ wrap_width, ImDrawTextFlags_WrapKeepBlanks | ImDrawTextFlags_CpuFineClip);++ // Render blinking cursor+ if (render_cursor)+ {+ state->CursorAnim += io.DeltaTime;+ bool cursor_is_visible = (!g.IO.ConfigInputTextCursorBlink) || (state->CursorAnim <= 0.0f) || ImFmod(state->CursorAnim, 1.20f) <= 0.80f;+ ImVec2 cursor_screen_pos = ImTrunc(draw_pos + cursor_offset - draw_scroll);+ ImRect cursor_screen_rect = ImRect(cursor_screen_pos.x, cursor_screen_pos.y - g.FontSize + 1.0f, cursor_screen_pos.x + 1.0f, cursor_screen_pos.y - 1.0f);+ if (cursor_is_visible && cursor_screen_rect.Overlaps(clip_rect))+ draw_window->DrawList->AddLineV(cursor_screen_rect.Min.x, cursor_screen_rect.Min.y, cursor_screen_rect.Max.y, GetColorU32(ImGuiCol_InputTextCursor), style.InputTextCursorSize, ImDrawFlags_StrokeInside);++ // Notify OS of text input position for advanced IME (-1 x offset so that Windows IME can cover our cursor. Bit of an extra nicety.)+ // This is required for some backends (SDL3) to start emitting character/text inputs.+ // As per #6341, make sure we don't set that on the deactivating frame.+ if (!is_readonly && g.ActiveId == id)+ {+ ImGuiPlatformImeData* ime_data = &g.PlatformImeData; // (this is a public struct, passed to io.Platform_SetImeDataFn() handler)+ ime_data->WantVisible = true;+ ime_data->WantTextInput = true;+ ime_data->InputPos = ImVec2(cursor_screen_pos.x - 1.0f, cursor_screen_pos.y - g.FontSize);+ ime_data->InputLineHeight = g.FontSize;+ ime_data->ViewportId = window->Viewport->ID;+ }+ }++ if (is_password && !is_displaying_hint)+ PopPasswordFont();++ if (is_multiline)+ {+ // For focus requests to work on our multiline we need to ensure our child ItemAdd() call specifies the ImGuiItemFlags_Inputable (see #4761, #7870)...+ Dummy(ImVec2(0.0f, text_size_y + style.FramePadding.y));+ g.NextItemData.ItemFlagsSet |= (ImGuiItemFlags)ImGuiItemFlags_Inputable | ImGuiItemFlags_NoTabStop;+ EndChild();+ item_data_backup.StatusFlags |= (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HoveredWindow);++ // ...and then we need to undo the group overriding last item data, which gets a bit messy as EndGroup() tries to forward scrollbar being active...+ // FIXME: This quite messy/tricky, should attempt to get rid of the child window.+ EndGroup();+ if (g.LastItemData.ID == 0 || g.LastItemData.ID != GetWindowScrollbarID(draw_window, ImGuiAxis_Y))+ {+ g.LastItemData.ID = id;+ g.LastItemData.ItemFlags = item_data_backup.ItemFlags;+ g.LastItemData.StatusFlags = item_data_backup.StatusFlags;+ }+ }+ if (state && is_readonly)+ state->TextSrc = NULL;++ // Log as text+ if (g.LogEnabled && (!is_password || is_displaying_hint))+ {+ LogSetNextTextDecoration("{", "}");+ LogRenderedText(&draw_pos, buf_display, buf_display_end);+ }++ if (label_size.x > 0)+ RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label, label_end, false);++ if (state && validated)+ state->ValidatedThisFrame = true;+ if (value_changed)+ MarkItemEdited(id);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Inputable);+ if ((flags & ImGuiInputTextFlags_EnterReturnsTrue) != 0)+ return validated;+ else+ return value_changed;+}++void ImGui::DebugNodeInputTextState(ImGuiInputTextState* state)+{+#ifndef IMGUI_DISABLE_DEBUG_TOOLS+ ImGuiContext& g = *GImGui;+ ImStb::STB_TexteditState* stb_state = state->Stb;+ ImStb::StbUndoState* undo_state = &stb_state->undostate;+ Text("ID: 0x%08X, ActiveID: 0x%08X", state->ID, g.ActiveId);+ DebugLocateItemOnHover(state->ID);+ Text("TextLen: %d, Cursor: %d%s, Selection: %d..%d", state->TextLen, stb_state->cursor,+ (state->Flags & ImGuiInputTextFlags_WordWrap) ? (state->LastMoveDirectionLR == ImGuiDir_Left ? " (L)" : " (R)") : "",+ stb_state->select_start, stb_state->select_end);+ Text("BufCapacity: %d, LineCount: %d", state->BufCapacity, state->LineCount);+ Text("(Internal Buffer: TextA Size: %d, Capacity: %d)", state->TextA.Size, state->TextA.Capacity);+ Text("has_preferred_x: %d (%.2f)", stb_state->has_preferred_x, stb_state->preferred_x);+ Text("undo_point: %d, redo_point: %d, undo_char_point: %d, redo_char_point: %d", undo_state->undo_point, undo_state->redo_point, undo_state->undo_char_point, undo_state->redo_char_point);+ if (BeginChild("undopoints", ImVec2(0.0f, GetTextLineHeight() * 10), ImGuiChildFlags_Borders | ImGuiChildFlags_ResizeY)) // Visualize undo state+ {+ PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));+ for (int n = 0; n < IMSTB_TEXTEDIT_UNDOSTATECOUNT; n++)+ {+ ImStb::StbUndoRecord* undo_rec = &undo_state->undo_rec[n];+ const char undo_rec_type = (n < undo_state->undo_point) ? 'u' : (n >= undo_state->redo_point) ? 'r' : ' ';+ if (undo_rec_type == ' ')+ BeginDisabled();+ const int buf_preview_len = (undo_rec_type != ' ' && undo_rec->char_storage != -1) ? undo_rec->insert_length : 0;+ const char* buf_preview_str = undo_state->undo_char + undo_rec->char_storage;+ Text("%c [%02d] where %03d, insert %03d, delete %03d, char_storage %03d \"%.*s\"",+ undo_rec_type, n, undo_rec->where, undo_rec->insert_length, undo_rec->delete_length, undo_rec->char_storage, buf_preview_len, buf_preview_str);+ if (undo_rec_type == ' ')+ EndDisabled();+ }+ PopStyleVar();+ }+ EndChild();+#else+ IM_UNUSED(state);+#endif+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: ColorEdit, ColorPicker, ColorButton, etc.+//-------------------------------------------------------------------------+// - ColorEdit3()+// - ColorEdit4()+// - ColorPicker3()+// - RenderColorRectWithAlphaCheckerboard() [Internal]+// - ColorPicker4()+// - ColorButton()+// - ColorTooltip() [Internal]+// - ColorEditOptionsPopup() [Internal]+// - ColorPickerOptionsPopup() [Internal]+//-------------------------------------------------------------------------++bool ImGui::ColorEdit3(const char* label, float col[3], ImGuiColorEditFlags flags)+{+ return ColorEdit4(label, col, flags | ImGuiColorEditFlags_NoAlpha);+}++static void ColorEditRestoreH(const float* col, float* H)+{+ ImGuiContext& g = *GImGui;+ IM_ASSERT(g.ColorEditCurrentID != 0);+ if (g.ColorEditSavedID != g.ColorEditCurrentID || g.ColorEditSavedColor != ImGui::ColorConvertFloat4ToU32(ImVec4(col[0], col[1], col[2], 0)))+ return;+ *H = g.ColorEditSavedHue;+}++// ColorEdit supports RGB and HSV inputs. In case of RGB input resulting color may have undefined hue and/or saturation.+// Since widget displays both RGB and HSV values we must preserve hue and saturation to prevent these values resetting.+static void ColorEditRestoreHS(const float* col, float* H, float* S, float* V)+{+ ImGuiContext& g = *GImGui;+ IM_ASSERT(g.ColorEditCurrentID != 0);+ if (g.ColorEditSavedID != g.ColorEditCurrentID || g.ColorEditSavedColor != ImGui::ColorConvertFloat4ToU32(ImVec4(col[0], col[1], col[2], 0)))+ return;++ // When S == 0, H is undefined.+ // When H == 1 it wraps around to 0.+ if (*S == 0.0f || (*H == 0.0f && g.ColorEditSavedHue == 1))+ *H = g.ColorEditSavedHue;++ // When V == 0, S is undefined.+ if (*V == 0.0f)+ *S = g.ColorEditSavedSat;+}++// Edit colors components (each component in 0.0f..1.0f range).+// See enum ImGuiColorEditFlags_ for available options. e.g. Only access 3 floats if ImGuiColorEditFlags_NoAlpha flag is set.+// With typical options: Left-click on color square to open color picker. Right-click to open option menu. Ctrl+Click over input fields to edit them and TAB to go to next item.+bool ImGui::ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;+ const float square_sz = GetFrameHeight();+ const char* label_display_end = FindRenderedTextEnd(label);+ float w_full = CalcItemWidth();+ g.NextItemData.ClearFlags();++ BeginGroup();+ PushID(label);+ const bool set_current_color_edit_id = (g.ColorEditCurrentID == 0);+ if (set_current_color_edit_id)+ g.ColorEditCurrentID = window->IDStack.back();++ // If we're not showing any slider there's no point in doing any HSV conversions+ const ImGuiColorEditFlags flags_untouched = flags;+ if (flags & ImGuiColorEditFlags_NoInputs)+ flags = (flags & (~ImGuiColorEditFlags_DisplayMask_)) | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_NoOptions;++ // Context menu: display and modify options (before defaults are applied)+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ ColorEditOptionsPopup(col, flags);++ // Read stored options+ if (!(flags & ImGuiColorEditFlags_DisplayMask_))+ flags |= (g.IO.ConfigColorEditFlags & ImGuiColorEditFlags_DisplayMask_);+ if (!(flags & ImGuiColorEditFlags_DataTypeMask_))+ flags |= (g.IO.ConfigColorEditFlags & ImGuiColorEditFlags_DataTypeMask_);+ if (!(flags & ImGuiColorEditFlags_PickerMask_))+ flags |= (g.IO.ConfigColorEditFlags & ImGuiColorEditFlags_PickerMask_);+ if (!(flags & ImGuiColorEditFlags_InputMask_))+ flags |= (g.IO.ConfigColorEditFlags & ImGuiColorEditFlags_InputMask_);+ flags |= (g.IO.ConfigColorEditFlags & ~(ImGuiColorEditFlags_DisplayMask_ | ImGuiColorEditFlags_DataTypeMask_ | ImGuiColorEditFlags_PickerMask_ | ImGuiColorEditFlags_InputMask_));+ IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags_DisplayMask_)); // Check that only 1 is selected+ IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags_InputMask_)); // Check that only 1 is selected++ const bool alpha = (flags & ImGuiColorEditFlags_NoAlpha) == 0;+ const bool hdr = (flags & ImGuiColorEditFlags_HDR) != 0;+ const int components = alpha ? 4 : 3;+ const float w_button = (flags & ImGuiColorEditFlags_NoSmallPreview) ? 0.0f : (square_sz + style.ItemInnerSpacing.x);+ const float w_inputs = ImMax(w_full - w_button, 1.0f);+ w_full = w_inputs + w_button;++ // Convert to the formats we need+ float f[4] = { col[0], col[1], col[2], alpha ? col[3] : 1.0f };+ if ((flags & ImGuiColorEditFlags_InputHSV) && (flags & ImGuiColorEditFlags_DisplayRGB))+ ColorConvertHSVtoRGB(f[0], f[1], f[2], f[0], f[1], f[2]);+ else if ((flags & ImGuiColorEditFlags_InputRGB) && (flags & ImGuiColorEditFlags_DisplayHSV))+ {+ // Hue is lost when converting from grayscale rgb (saturation=0). Restore it.+ ColorConvertRGBtoHSV(f[0], f[1], f[2], f[0], f[1], f[2]);+ ColorEditRestoreHS(col, &f[0], &f[1], &f[2]);+ }+ int i[4] = { IM_F32_TO_INT8_UNBOUND(f[0]), IM_F32_TO_INT8_UNBOUND(f[1]), IM_F32_TO_INT8_UNBOUND(f[2]), IM_F32_TO_INT8_UNBOUND(f[3]) };++ bool value_changed = false;+ bool value_changed_as_float = false;++ const ImVec2 pos = window->DC.CursorPos;+ const float inputs_offset_x = (style.ColorButtonPosition == ImGuiDir_Left) ? w_button : 0.0f;+ window->DC.CursorPos.x = pos.x + inputs_offset_x;++ if ((flags & (ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV)) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)+ {+ // RGB/HSV 0..255 Sliders+ const float w_items = w_inputs - (BuiOn() ? 0.0f : style.ItemInnerSpacing.x * (components - 1)); // BUI: an aligned row+ const float w_per_component = IM_TRUNC(w_items / components);+ const bool draw_color_marker = (flags & (ImGuiColorEditFlags_DisplayHSV | ImGuiColorEditFlags_NoColorMarkers)) == 0;++ const bool hide_prefix = draw_color_marker || (w_per_component <= CalcTextSize((flags & ImGuiColorEditFlags_Float) ? "M:0.000" : "M:000").x);+ static const char* ids[4] = { "##X", "##Y", "##Z", "##W" };+ static const char* fmt_table_int[3][4] =+ {+ { "%3d", "%3d", "%3d", "%3d" }, // Short display+ { "R:%3d", "G:%3d", "B:%3d", "A:%3d" }, // Long display for RGBA+ { "H:%3d", "S:%3d", "V:%3d", "A:%3d" } // Long display for HSVA+ };+ static const char* fmt_table_float[3][4] =+ {+ { "%0.3f", "%0.3f", "%0.3f", "%0.3f" }, // Short display+ { "R:%0.3f", "G:%0.3f", "B:%0.3f", "A:%0.3f" }, // Long display for RGBA+ { "H:%0.3f", "S:%0.3f", "V:%0.3f", "A:%0.3f" } // Long display for HSVA+ };+ const int fmt_idx = hide_prefix ? 0 : (flags & ImGuiColorEditFlags_DisplayHSV) ? 2 : 1;+ const ImGuiSliderFlags drag_flags = draw_color_marker ? ImGuiSliderFlags_ColorMarkers : ImGuiSliderFlags_None;++ float prev_split = 0.0f;+ for (int n = 0; n < components; n++)+ {+ if (n > 0)+ SameLine(0, BuiOn() ? 0.0f : style.ItemInnerSpacing.x); // BUI+ BuiAlignItem(n, components); // BUI+ float next_split = IM_TRUNC(w_items * (n + 1) / components);+ SetNextItemWidth(ImMax(next_split - prev_split, 1.0f));+ prev_split = next_split;+ if (draw_color_marker)+ SetNextItemColorMarker(GDefaultRgbaColorMarkers[n]);++ // FIXME: When ImGuiColorEditFlags_HDR flag is passed HS values snap in weird ways when SV values go below 0.+ if (flags & ImGuiColorEditFlags_Float)+ {+ value_changed |= DragFloat(ids[n], &f[n], 1.0f / 255.0f, 0.0f, hdr ? 0.0f : 1.0f, fmt_table_float[fmt_idx][n], drag_flags);+ value_changed_as_float |= value_changed;+ }+ else+ {+ value_changed |= DragInt(ids[n], &i[n], 1.0f, 0, hdr ? 0 : 255, fmt_table_int[fmt_idx][n], drag_flags);+ }+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);+ }+ BuiAlignEnd(); // BUI+ }+ else if ((flags & ImGuiColorEditFlags_DisplayHex) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)+ {+ // RGB Hexadecimal Input+ char buf[64];+ if (alpha)+ ImFormatString(buf, IM_COUNTOF(buf), "#%02X%02X%02X%02X", ImClamp(i[0], 0, 255), ImClamp(i[1], 0, 255), ImClamp(i[2], 0, 255), ImClamp(i[3], 0, 255));+ else+ ImFormatString(buf, IM_COUNTOF(buf), "#%02X%02X%02X", ImClamp(i[0], 0, 255), ImClamp(i[1], 0, 255), ImClamp(i[2], 0, 255));+ SetNextItemWidth(w_inputs);+ if (InputText("##Text", buf, IM_COUNTOF(buf), ImGuiInputTextFlags_CharsUppercase))+ {+ value_changed = true;+ char* p = buf;+ while (*p == '#' || ImCharIsBlankA(*p))+ p++;+ i[0] = i[1] = i[2] = 0;+ i[3] = 0xFF; // alpha default to 255 is not parsed by scanf (e.g. inputting #FFFFFF omitting alpha)+ int r;+ if (alpha)+ r = sscanf(p, "%02X%02X%02X%02X", (unsigned int*)&i[0], (unsigned int*)&i[1], (unsigned int*)&i[2], (unsigned int*)&i[3]); // Treat at unsigned (%X is unsigned)+ else+ r = sscanf(p, "%02X%02X%02X", (unsigned int*)&i[0], (unsigned int*)&i[1], (unsigned int*)&i[2]);+ IM_UNUSED(r); // Fixes C6031: Return value ignored: 'sscanf'.+ }+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);+ }++ ImGuiWindow* picker_active_window = NULL;+ if (!(flags & ImGuiColorEditFlags_NoSmallPreview))+ {+ const float button_offset_x = ((flags & ImGuiColorEditFlags_NoInputs) || (style.ColorButtonPosition == ImGuiDir_Left)) ? 0.0f : w_inputs + style.ItemInnerSpacing.x;+ window->DC.CursorPos = ImVec2(pos.x + button_offset_x, pos.y);++ const ImVec4 col_v4(col[0], col[1], col[2], alpha ? col[3] : 1.0f);+ if (ColorButton("##ColorButton", col_v4, flags))+ {+ if (!(flags & ImGuiColorEditFlags_NoPicker))+ {+ // Store current color and open a picker+ g.ColorPickerRef = col_v4;+ OpenPopup("picker");+ SetNextWindowPos(g.LastItemData.Rect.GetBL() + ImVec2(0.0f, style.ItemSpacing.y));+ }+ }+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);++ if (BeginPopup("picker"))+ {+ if (g.CurrentWindow->BeginCount == 1)+ {+ picker_active_window = g.CurrentWindow;+ if (label != label_display_end)+ {+ TextEx(label, label_display_end);+ Spacing();+ }+ ImGuiColorEditFlags picker_flags_to_forward = ImGuiColorEditFlags_DataTypeMask_ | ImGuiColorEditFlags_PickerMask_ | ImGuiColorEditFlags_InputMask_ | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaBar;+ ImGuiColorEditFlags picker_flags = (flags_untouched & picker_flags_to_forward) | ImGuiColorEditFlags_DisplayMask_ | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_AlphaPreviewHalf;+ SetNextItemWidth(square_sz * 12.0f); // Use 256 + bar sizes?+ PushItemFlag(ImGuiItemFlags_MixedValue, false);+ value_changed |= ColorPicker4("##picker", col, picker_flags, &g.ColorPickerRef.x);+ PopItemFlag();+ }+ EndPopup();+ }+ }++ if (label != label_display_end && !(flags & ImGuiColorEditFlags_NoLabel))+ {+ // Position not necessarily next to last submitted button (e.g. if style.ColorButtonPosition == ImGuiDir_Left),+ // but we need to use SameLine() to setup baseline correctly. Might want to refactor SameLine() to simplify this.+ SameLine(0.0f, style.ItemInnerSpacing.x);+ window->DC.CursorPos.x = pos.x + ((flags & ImGuiColorEditFlags_NoInputs) ? w_button : w_full + style.ItemInnerSpacing.x);+ TextEx(label, label_display_end);+ }++ // Convert back+ if (value_changed && picker_active_window == NULL)+ {+ if (!value_changed_as_float)+ for (int n = 0; n < 4; n++)+ f[n] = i[n] / 255.0f;+ if ((flags & ImGuiColorEditFlags_DisplayHSV) && (flags & ImGuiColorEditFlags_InputRGB))+ {+ g.ColorEditSavedHue = f[0];+ g.ColorEditSavedSat = f[1];+ ColorConvertHSVtoRGB(f[0], f[1], f[2], f[0], f[1], f[2]);+ g.ColorEditSavedID = g.ColorEditCurrentID;+ g.ColorEditSavedColor = ColorConvertFloat4ToU32(ImVec4(f[0], f[1], f[2], 0));+ }+ if ((flags & ImGuiColorEditFlags_DisplayRGB) && (flags & ImGuiColorEditFlags_InputHSV))+ ColorConvertRGBtoHSV(f[0], f[1], f[2], f[0], f[1], f[2]);++ col[0] = f[0];+ col[1] = f[1];+ col[2] = f[2];+ if (alpha)+ col[3] = f[3];+ }++ if (set_current_color_edit_id)+ g.ColorEditCurrentID = 0;+ PopID();+ EndGroup();++ // Drag and Drop Target+ // NB: The flag test is merely an optional micro-optimization, BeginDragDropTarget() does the same test.+ if ((g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HoveredRect) && !(g.LastItemData.ItemFlags & ImGuiItemFlags_ReadOnly) && !(flags & ImGuiColorEditFlags_NoDragDrop) && BeginDragDropTarget())+ {+ bool accepted_drag_drop = false;+ if (const ImGuiPayload* payload = AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_3F))+ {+ memcpy((float*)col, payload->Data, sizeof(float) * 3); // Preserve alpha if any //-V512 //-V1086+ value_changed = accepted_drag_drop = true;+ }+ if (const ImGuiPayload* payload = AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_4F))+ {+ memcpy((float*)col, payload->Data, sizeof(float) * components);+ value_changed = accepted_drag_drop = true;+ }++ // Drag-drop payloads are always RGB+ if (accepted_drag_drop && (flags & ImGuiColorEditFlags_InputHSV))+ ColorConvertRGBtoHSV(col[0], col[1], col[2], col[0], col[1], col[2]);+ EndDragDropTarget();+ }++ // When picker is being actively used, use its active id so IsItemActive() will function on ColorEdit4().+ if (picker_active_window && g.ActiveId != 0 && g.ActiveIdWindow == picker_active_window)+ g.LastItemData.ID = g.ActiveId;++ if (value_changed && g.LastItemData.ID != 0) // In case of ID collision, the second EndGroup() won't catch g.ActiveId+ MarkItemEdited(g.LastItemData.ID);++ return value_changed;+}++bool ImGui::ColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags)+{+ float col4[4] = { col[0], col[1], col[2], 1.0f };+ if (!ColorPicker4(label, col4, flags | ImGuiColorEditFlags_NoAlpha))+ return false;+ col[0] = col4[0]; col[1] = col4[1]; col[2] = col4[2];+ return true;+}++// Helper for RenderArrowsForVerticalBar(). 'pos' is position of the arrow tip. half_sz.x is length from base to tip. half_sz.y is length on each side.+static void RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 p, ImVec2 half_sz, ImGuiDir direction, ImU32 col)+{+ if (direction == ImGuiDir_Left) { draw_list->AddTriangleFilled(ImVec2(p.x + half_sz.x, p.y - half_sz.y), ImVec2(p.x + half_sz.x, p.y + half_sz.y), p, col); }+ if (direction == ImGuiDir_Right) { draw_list->AddTriangleFilled(ImVec2(p.x - half_sz.x, p.y + half_sz.y), ImVec2(p.x - half_sz.x, p.y - half_sz.y), p, col); }+ //if (direction == ImGuiDir_Up) { draw_list->AddTriangleFilled(ImVec2(p.x + half_sz.x, p.y + half_sz.y), ImVec2(p.x - half_sz.x, p.y + half_sz.y), p, col); }+ //if (direction == ImGuiDir_Down){ draw_list->AddTriangleFilled(ImVec2(p.x - half_sz.x, p.y - half_sz.y), ImVec2(p.x + half_sz.x, p.y - half_sz.y), p, col); }+}++// Helper for ColorPicker4()+static void RenderArrowsForVerticalBar(ImDrawList* draw_list, ImVec2 p, ImVec2 half_sz, float bar_w, float alpha)+{+ ImU32 alpha8 = IM_F32_TO_INT8_SAT(alpha);+ RenderArrowPointingAt(draw_list, ImVec2(p.x + half_sz.x + 1, p.y), ImVec2(half_sz.x + 2, half_sz.y + 1), ImGuiDir_Right, IM_COL32(0,0,0,alpha8));+ RenderArrowPointingAt(draw_list, ImVec2(p.x + half_sz.x, p.y), half_sz, ImGuiDir_Right, IM_COL32(255,255,255,alpha8));+ RenderArrowPointingAt(draw_list, ImVec2(p.x + bar_w - half_sz.x - 1, p.y), ImVec2(half_sz.x + 2, half_sz.y + 1), ImGuiDir_Left, IM_COL32(0,0,0,alpha8));+ RenderArrowPointingAt(draw_list, ImVec2(p.x + bar_w - half_sz.x, p.y), half_sz, ImGuiDir_Left, IM_COL32(255,255,255,alpha8));+}++// Note: ColorPicker4() only accesses 3 floats if ImGuiColorEditFlags_NoAlpha flag is set.+// (In C++ the 'float col[4]' notation for a function argument is equivalent to 'float* col', we only specify a size to facilitate understanding of the code.)+// FIXME: we adjust the big color square height based on item width, which may cause a flickering feedback loop (if automatic height makes a vertical scrollbar appears, affecting automatic width..)+// FIXME: this is trying to be aware of style.Alpha but not fully correct. Also, the color wheel will have overlapping glitches with (style.Alpha < 1.0)+bool ImGui::ColorPicker4(const char* label, float col[4], ImGuiColorEditFlags flags, const float* ref_col)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImDrawList* draw_list = window->DrawList;+ ImGuiStyle& style = g.Style;+ ImGuiIO& io = g.IO;++ const float width = CalcItemWidth();+ const bool is_readonly = ((g.NextItemData.ItemFlagsSet | g.CurrentItemFlags) & ImGuiItemFlags_ReadOnly) != 0;+ g.NextItemData.ClearFlags();++ const float backup_alpha = g.Style.Alpha;+ if (g.DisabledStackSize > 0)+ g.Style.Alpha = g.DisabledAlphaBackup; // Cancel out effect of BeginDisabled() for color swatches.++ PushID(label);+ const bool set_current_color_edit_id = (g.ColorEditCurrentID == 0);+ if (set_current_color_edit_id)+ g.ColorEditCurrentID = window->IDStack.back();+ BeginGroup();++ if (!(flags & ImGuiColorEditFlags_NoSidePreview))+ flags |= ImGuiColorEditFlags_NoSmallPreview;++ // Context menu: display and store options.+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ ColorPickerOptionsPopup(col, flags);++ // Read stored options+ if (!(flags & ImGuiColorEditFlags_PickerMask_))+ flags |= ((g.IO.ConfigColorEditFlags & ImGuiColorEditFlags_PickerMask_) ? g.IO.ConfigColorEditFlags : ImGuiColorEditFlags_DefaultOptions_) & ImGuiColorEditFlags_PickerMask_;+ if (!(flags & ImGuiColorEditFlags_InputMask_))+ flags |= ((g.IO.ConfigColorEditFlags & ImGuiColorEditFlags_InputMask_) ? g.IO.ConfigColorEditFlags : ImGuiColorEditFlags_DefaultOptions_) & ImGuiColorEditFlags_InputMask_;+ IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags_PickerMask_)); // Check that only 1 is selected+ IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags_InputMask_)); // Check that only 1 is selected+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ flags |= (g.IO.ConfigColorEditFlags & ImGuiColorEditFlags_AlphaBar);++ // Setup+ int components = (flags & ImGuiColorEditFlags_NoAlpha) ? 3 : 4;+ bool alpha_bar = (flags & ImGuiColorEditFlags_AlphaBar) && !(flags & ImGuiColorEditFlags_NoAlpha);+ ImVec2 picker_pos = window->DC.CursorPos;+ float square_sz = GetFrameHeight();+ float bars_width = square_sz; // Arbitrary smallish width of Hue/Alpha picking bars+ float sv_picker_size = ImMax(bars_width * 1, width - (alpha_bar ? 2 : 1) * (bars_width + style.ItemInnerSpacing.x)); // Saturation/Value picking box+ float bar0_pos_x = picker_pos.x + sv_picker_size + style.ItemInnerSpacing.x;+ float bar1_pos_x = bar0_pos_x + bars_width + style.ItemInnerSpacing.x;+ float bars_triangles_half_sz = IM_TRUNC(bars_width * 0.20f);++ float backup_initial_col[4];+ memcpy(backup_initial_col, col, components * sizeof(float));++ float wheel_thickness = sv_picker_size * 0.08f;+ float wheel_r_outer = sv_picker_size * 0.50f;+ float wheel_r_inner = wheel_r_outer - wheel_thickness;+ ImVec2 wheel_center(picker_pos.x + (sv_picker_size + bars_width)*0.5f, picker_pos.y + sv_picker_size * 0.5f);++ // Note: the triangle is displayed rotated with triangle_pa pointing to Hue, but most coordinates stays unrotated for logic.+ const bool triangle_rotate = (flags & ImGuiColorEditFlags_PickerNoRotate) == 0;+ float triangle_r = wheel_r_inner - (int)(sv_picker_size * 0.027f);+ ImVec2 triangle_pa = triangle_rotate ? ImVec2(triangle_r, 0.0f) : ImVec2(triangle_r * +0.866f, triangle_r * +0.5f); // Hue point.+ ImVec2 triangle_pb = triangle_rotate ? ImVec2(triangle_r * -0.5f, triangle_r * -0.866f) : ImVec2(0.0f, -triangle_r); // Black point.+ ImVec2 triangle_pc = triangle_rotate ? ImVec2(triangle_r * -0.5f, triangle_r * +0.866f) : ImVec2(triangle_r * -0.866f, triangle_r * +0.5f); // White point.++ float H = col[0], S = col[1], V = col[2];+ float R = col[0], G = col[1], B = col[2];+ if (flags & ImGuiColorEditFlags_InputRGB)+ {+ // Hue is lost when converting from grayscale rgb (saturation=0). Restore it.+ ColorConvertRGBtoHSV(R, G, B, H, S, V);+ ColorEditRestoreHS(col, &H, &S, &V);+ }+ else if (flags & ImGuiColorEditFlags_InputHSV)+ {+ ColorConvertHSVtoRGB(H, S, V, R, G, B);+ }++ bool value_changed = false, value_changed_h = false, value_changed_sv = false;++ PushItemFlag(ImGuiItemFlags_NoNav, true);+ if (flags & ImGuiColorEditFlags_PickerHueWheel)+ {+ // Hue wheel + SV triangle logic+ InvisibleButton("hsv", ImVec2(sv_picker_size + style.ItemInnerSpacing.x + bars_width, sv_picker_size));+ if (IsItemActive() && !is_readonly)+ {+ ImVec2 initial_off = g.IO.MouseClickedPos[0] - wheel_center;+ ImVec2 current_off = g.IO.MousePos - wheel_center;+ float initial_dist2 = ImLengthSqr(initial_off);+ if (initial_dist2 >= (wheel_r_inner - 1) * (wheel_r_inner - 1) && initial_dist2 <= (wheel_r_outer + 1) * (wheel_r_outer + 1))+ {+ // Interactive with Hue wheel+ H = ImAtan2(current_off.y, current_off.x) / IM_PI * 0.5f;+ if (H < 0.0f)+ H += 1.0f;+ value_changed = value_changed_h = true;+ }+ float cos_hue_angle = triangle_rotate ? ImCos(-H * 2.0f * IM_PI) : 1.0f;+ float sin_hue_angle = triangle_rotate ? ImSin(-H * 2.0f * IM_PI) : 0.0f;+ if (ImTriangleContainsPoint(triangle_pa, triangle_pb, triangle_pc, ImRotate(initial_off, cos_hue_angle, sin_hue_angle)))+ {+ // Interacting with SV triangle+ ImVec2 current_off_unrotated = ImRotate(current_off, cos_hue_angle, sin_hue_angle);+ if (!ImTriangleContainsPoint(triangle_pa, triangle_pb, triangle_pc, current_off_unrotated))+ current_off_unrotated = ImTriangleClosestPoint(triangle_pa, triangle_pb, triangle_pc, current_off_unrotated);+ float uu, vv, ww;+ ImTriangleBarycentricCoords(triangle_pa, triangle_pb, triangle_pc, current_off_unrotated, uu, vv, ww);+ V = ImClamp(1.0f - vv, 0.0001f, 1.0f);+ S = ImClamp(uu / V, 0.0001f, 1.0f);+ value_changed = value_changed_sv = true;+ }+ }+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);+ }+ else if (flags & ImGuiColorEditFlags_PickerHueBar)+ {+ // SV rectangle logic+ InvisibleButton("sv", ImVec2(sv_picker_size, sv_picker_size));+ if (IsItemActive() && !is_readonly)+ {+ S = ImSaturate((io.MousePos.x - picker_pos.x) / (sv_picker_size - 1));+ V = 1.0f - ImSaturate((io.MousePos.y - picker_pos.y) / (sv_picker_size - 1));+ ColorEditRestoreH(col, &H); // Greatly reduces hue jitter and reset to 0 when hue == 255 and color is rapidly modified using SV square.+ value_changed = value_changed_sv = true;+ }+ if (!(flags & ImGuiColorEditFlags_NoOptions))+ OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);++ // Hue bar logic+ SetCursorScreenPos(ImVec2(bar0_pos_x, picker_pos.y));+ InvisibleButton("hue", ImVec2(bars_width, sv_picker_size));+ if (IsItemActive() && !is_readonly)+ {+ H = ImSaturate((io.MousePos.y - picker_pos.y) / (sv_picker_size - 1));+ value_changed = value_changed_h = true;+ }+ }++ // Alpha bar logic+ if (alpha_bar)+ {+ SetCursorScreenPos(ImVec2(bar1_pos_x, picker_pos.y));+ InvisibleButton("alpha", ImVec2(bars_width, sv_picker_size));+ if (IsItemActive())+ {+ col[3] = 1.0f - ImSaturate((io.MousePos.y - picker_pos.y) / (sv_picker_size - 1));+ value_changed = true;+ }+ }+ PopItemFlag(); // ImGuiItemFlags_NoNav++ if (!(flags & ImGuiColorEditFlags_NoSidePreview))+ {+ SameLine(0, style.ItemInnerSpacing.x);+ BeginGroup();+ }++ if (!(flags & ImGuiColorEditFlags_NoLabel))+ {+ const char* label_display_end = FindRenderedTextEnd(label);+ if (label != label_display_end)+ {+ if ((flags & ImGuiColorEditFlags_NoSidePreview))+ SameLine(0, style.ItemInnerSpacing.x);+ TextEx(label, label_display_end);+ }+ }++ if (!(flags & ImGuiColorEditFlags_NoSidePreview))+ {+ PushItemFlag(ImGuiItemFlags_NoNavDefaultFocus, true);+ PushItemFlag(ImGuiItemFlags_MixedValue, false);+ ImVec4 col_v4(col[0], col[1], col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : col[3]);+ if ((flags & ImGuiColorEditFlags_NoLabel))+ Text("Current");++ ImGuiColorEditFlags sub_flags_to_forward = ImGuiColorEditFlags_InputMask_ | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_AlphaMask_ | ImGuiColorEditFlags_NoTooltip;+ ColorButton("##current", col_v4, (flags & sub_flags_to_forward), ImVec2(square_sz * 3, square_sz * 2));+ if (ref_col != NULL)+ {+ Text("Original");+ ImVec4 ref_col_v4(ref_col[0], ref_col[1], ref_col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : ref_col[3]);+ if (ColorButton("##original", ref_col_v4, (flags & sub_flags_to_forward), ImVec2(square_sz * 3, square_sz * 2)))+ {+ memcpy(col, ref_col, components * sizeof(float));+ value_changed = true;+ }+ }+ PopItemFlag();+ PopItemFlag();+ EndGroup();+ }++ // Convert back color to RGB+ if (value_changed_h || value_changed_sv)+ {+ if (flags & ImGuiColorEditFlags_InputRGB)+ {+ ColorConvertHSVtoRGB(H, S, V, col[0], col[1], col[2]);+ g.ColorEditSavedHue = H;+ g.ColorEditSavedSat = S;+ g.ColorEditSavedID = g.ColorEditCurrentID;+ g.ColorEditSavedColor = ColorConvertFloat4ToU32(ImVec4(col[0], col[1], col[2], 0));+ }+ else if (flags & ImGuiColorEditFlags_InputHSV)+ {+ col[0] = H;+ col[1] = S;+ col[2] = V;+ }+ }++ // R,G,B and H,S,V slider color editor+ bool value_changed_fix_hue_wrap = false;+ if ((flags & ImGuiColorEditFlags_NoInputs) == 0)+ {+ PushItemWidth((alpha_bar ? bar1_pos_x : bar0_pos_x) + bars_width - picker_pos.x);+ ImGuiColorEditFlags sub_flags_to_forward = ImGuiColorEditFlags_DataTypeMask_ | ImGuiColorEditFlags_InputMask_ | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_AlphaMask_ | ImGuiColorEditFlags_NoOptions | ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_NoSmallPreview;+ ImGuiColorEditFlags sub_flags = (flags & sub_flags_to_forward) | ImGuiColorEditFlags_NoPicker;+ if (flags & ImGuiColorEditFlags_DisplayRGB || (flags & ImGuiColorEditFlags_DisplayMask_) == 0)+ if (ColorEdit4("##rgb", col, sub_flags | ImGuiColorEditFlags_DisplayRGB))+ {+ // FIXME: Hackily differentiating using the DragInt (ActiveId != 0 && !ActiveIdAllowOverlap) vs. using the InputText or DropTarget.+ // For the later we don't want to run the hue-wrap canceling code. If you are well versed in HSV picker please provide your input! (See #2050)+ value_changed_fix_hue_wrap = (g.ActiveId != 0 && !g.ActiveIdAllowOverlap);+ value_changed = true;+ }+ if (flags & ImGuiColorEditFlags_DisplayHSV || (flags & ImGuiColorEditFlags_DisplayMask_) == 0)+ value_changed |= ColorEdit4("##hsv", col, sub_flags | ImGuiColorEditFlags_DisplayHSV);+ if (flags & ImGuiColorEditFlags_DisplayHex || (flags & ImGuiColorEditFlags_DisplayMask_) == 0)+ value_changed |= ColorEdit4("##hex", col, sub_flags | ImGuiColorEditFlags_DisplayHex);+ PopItemWidth();+ }++ // Try to cancel hue wrap (after ColorEdit4 call), if any+ if (value_changed_fix_hue_wrap && (flags & ImGuiColorEditFlags_InputRGB))+ {+ float new_H, new_S, new_V;+ ColorConvertRGBtoHSV(col[0], col[1], col[2], new_H, new_S, new_V);+ if (new_H <= 0 && H > 0)+ {+ if (new_V <= 0 && V != new_V)+ ColorConvertHSVtoRGB(H, S, new_V <= 0 ? V * 0.5f : new_V, col[0], col[1], col[2]);+ else if (new_S <= 0)+ ColorConvertHSVtoRGB(H, new_S <= 0 ? S * 0.5f : new_S, new_V, col[0], col[1], col[2]);+ }+ }++ if (value_changed)+ {+ if (flags & ImGuiColorEditFlags_InputRGB)+ {+ R = col[0];+ G = col[1];+ B = col[2];+ ColorConvertRGBtoHSV(R, G, B, H, S, V);+ ColorEditRestoreHS(col, &H, &S, &V); // Fix local Hue as display below will use it immediately.+ }+ else if (flags & ImGuiColorEditFlags_InputHSV)+ {+ H = col[0];+ S = col[1];+ V = col[2];+ ColorConvertHSVtoRGB(H, S, V, R, G, B);+ }+ }++ const int style_alpha8 = IM_F32_TO_INT8_SAT(style.Alpha);+ const ImU32 col_black = IM_COL32(0,0,0,style_alpha8);+ const ImU32 col_white = IM_COL32(255,255,255,style_alpha8);+ const ImU32 col_midgrey = IM_COL32(128,128,128,style_alpha8);+ const ImU32 col_hues[6 + 1] = { IM_COL32(255,0,0,style_alpha8), IM_COL32(255,255,0,style_alpha8), IM_COL32(0,255,0,style_alpha8), IM_COL32(0,255,255,style_alpha8), IM_COL32(0,0,255,style_alpha8), IM_COL32(255,0,255,style_alpha8), IM_COL32(255,0,0,style_alpha8) };++ ImVec4 hue_color_f(1, 1, 1, style.Alpha); ColorConvertHSVtoRGB(H, 1, 1, hue_color_f.x, hue_color_f.y, hue_color_f.z);+ ImU32 hue_color32 = ColorConvertFloat4ToU32(hue_color_f);+ ImU32 user_col32_striped_of_alpha = ColorConvertFloat4ToU32(ImVec4(R, G, B, style.Alpha)); // Important: this is still including the main rendering/style alpha!!++ ImVec2 sv_cursor_pos;++ if (flags & ImGuiColorEditFlags_PickerHueWheel)+ {+ // Render Hue Wheel+ const float aeps = 0.5f / wheel_r_outer; // Half a pixel arc length in radians (2pi cancels out).+ const int segment_per_arc = ImMax(4, (int)wheel_r_outer / 12);+ for (int n = 0; n < 6; n++)+ {+ const float a0 = (n) /6.0f * 2.0f * IM_PI - aeps;+ const float a1 = (n+1.0f)/6.0f * 2.0f * IM_PI + aeps;+ const int vert_start_idx = draw_list->VtxBuffer.Size;+ draw_list->PathArcTo(wheel_center, (wheel_r_inner + wheel_r_outer)*0.5f, a0, a1, segment_per_arc);+ draw_list->PathStroke(col_white, wheel_thickness);+ const int vert_end_idx = draw_list->VtxBuffer.Size;++ // Paint colors over existing vertices+ ImVec2 gradient_p0(wheel_center.x + ImCos(a0) * wheel_r_inner, wheel_center.y + ImSin(a0) * wheel_r_inner);+ ImVec2 gradient_p1(wheel_center.x + ImCos(a1) * wheel_r_inner, wheel_center.y + ImSin(a1) * wheel_r_inner);+ ShadeVertsLinearColorGradientKeepAlpha(draw_list, vert_start_idx, vert_end_idx, gradient_p0, gradient_p1, col_hues[n], col_hues[n + 1]);+ }++ // Render Cursor + preview on Hue Wheel+ float cos_hue_angle = ImCos(H * 2.0f * IM_PI);+ float sin_hue_angle = ImSin(H * 2.0f * IM_PI);+ ImVec2 hue_cursor_pos(wheel_center.x + cos_hue_angle * (wheel_r_inner + wheel_r_outer) * 0.5f, wheel_center.y + sin_hue_angle * (wheel_r_inner + wheel_r_outer) * 0.5f);+ float hue_cursor_rad = value_changed_h ? wheel_thickness * 0.65f : wheel_thickness * 0.55f;+ int hue_cursor_segments = draw_list->_CalcCircleAutoSegmentCount(hue_cursor_rad); // Lock segment count so the +1 one matches others.+ draw_list->AddCircleFilled(hue_cursor_pos, hue_cursor_rad, hue_color32, hue_cursor_segments);+ draw_list->AddCircle(hue_cursor_pos, hue_cursor_rad + 1, col_midgrey, hue_cursor_segments);+ draw_list->AddCircle(hue_cursor_pos, hue_cursor_rad, col_white, hue_cursor_segments);+ if (triangle_rotate == false)+ {+ cos_hue_angle = 1.0f;+ sin_hue_angle = 0.0f;+ }++ // Render SV triangle (rotated according to hue)+ ImVec2 tra = wheel_center + ImRotate(triangle_pa, cos_hue_angle, sin_hue_angle);+ ImVec2 trb = wheel_center + ImRotate(triangle_pb, cos_hue_angle, sin_hue_angle);+ ImVec2 trc = wheel_center + ImRotate(triangle_pc, cos_hue_angle, sin_hue_angle);+ ImVec2 uv_white = GetFontTexUvWhitePixel();+ draw_list->PrimReserve(3, 3);+ draw_list->PrimVtx(tra, uv_white, hue_color32);+ draw_list->PrimVtx(trb, uv_white, col_black);+ draw_list->PrimVtx(trc, uv_white, col_white);+ draw_list->AddTriangle(tra, trb, trc, col_midgrey, 1.5f);+ sv_cursor_pos = ImLerp(ImLerp(trc, tra, ImSaturate(S)), trb, ImSaturate(1 - V));+ }+ else if (flags & ImGuiColorEditFlags_PickerHueBar)+ {+ // Render SV Square+ draw_list->AddRectFilledMultiColor(picker_pos, picker_pos + ImVec2(sv_picker_size, sv_picker_size), col_white, hue_color32, hue_color32, col_white);+ draw_list->AddRectFilledMultiColor(picker_pos, picker_pos + ImVec2(sv_picker_size, sv_picker_size), 0, 0, col_black, col_black);+ RenderFrameBorder(picker_pos, picker_pos + ImVec2(sv_picker_size, sv_picker_size), 0.0f);+ sv_cursor_pos.x = ImClamp(IM_ROUND(picker_pos.x + ImSaturate(S) * sv_picker_size), picker_pos.x + 2, picker_pos.x + sv_picker_size - 2); // Sneakily prevent the circle to stick out too much+ sv_cursor_pos.y = ImClamp(IM_ROUND(picker_pos.y + ImSaturate(1 - V) * sv_picker_size), picker_pos.y + 2, picker_pos.y + sv_picker_size - 2);++ // Render Hue Bar+ for (int i = 0; i < 6; ++i)+ draw_list->AddRectFilledMultiColor(ImVec2(bar0_pos_x, picker_pos.y + i * (sv_picker_size / 6)), ImVec2(bar0_pos_x + bars_width, picker_pos.y + (i + 1) * (sv_picker_size / 6)), col_hues[i], col_hues[i], col_hues[i + 1], col_hues[i + 1]);+ float bar0_line_y = IM_ROUND(picker_pos.y + H * sv_picker_size);+ RenderFrameBorder(ImVec2(bar0_pos_x, picker_pos.y), ImVec2(bar0_pos_x + bars_width, picker_pos.y + sv_picker_size), 0.0f);+ RenderArrowsForVerticalBar(draw_list, ImVec2(bar0_pos_x - 1, bar0_line_y), ImVec2(bars_triangles_half_sz + 1, bars_triangles_half_sz), bars_width + 2.0f, style.Alpha);+ }++ // Render cursor/preview circle (clamp S/V within 0..1 range because floating points colors may lead HSV values to be out of range)+ float sv_cursor_rad = value_changed_sv ? wheel_thickness * 0.55f : wheel_thickness * 0.40f;+ int sv_cursor_segments = draw_list->_CalcCircleAutoSegmentCount(sv_cursor_rad); // Lock segment count so the +1 one matches others.+ draw_list->AddCircleFilled(sv_cursor_pos, sv_cursor_rad, user_col32_striped_of_alpha, sv_cursor_segments);+ draw_list->AddCircle(sv_cursor_pos, sv_cursor_rad + 1, col_midgrey, sv_cursor_segments);+ draw_list->AddCircle(sv_cursor_pos, sv_cursor_rad, col_white, sv_cursor_segments);++ // Render alpha bar+ if (alpha_bar)+ {+ float alpha = ImSaturate(col[3]);+ ImRect bar1_bb(bar1_pos_x, picker_pos.y, bar1_pos_x + bars_width, picker_pos.y + sv_picker_size);+ RenderColorRectWithAlphaCheckerboard(draw_list, bar1_bb.Min, bar1_bb.Max, IM_COL32(0,0,0,0), style.Alpha, bar1_bb.GetWidth() / 2.0f, ImVec2(0.0f, 0.0f));+ draw_list->AddRectFilledMultiColor(bar1_bb.Min, bar1_bb.Max, user_col32_striped_of_alpha, user_col32_striped_of_alpha, user_col32_striped_of_alpha & ~IM_COL32_A_MASK, user_col32_striped_of_alpha & ~IM_COL32_A_MASK);+ float bar1_line_y = IM_ROUND(picker_pos.y + (1.0f - alpha) * sv_picker_size);+ RenderFrameBorder(bar1_bb.Min, bar1_bb.Max, 0.0f);+ RenderArrowsForVerticalBar(draw_list, ImVec2(bar1_pos_x - 1, bar1_line_y), ImVec2(bars_triangles_half_sz + 1, bars_triangles_half_sz), bars_width + 2.0f, style.Alpha);+ }++ EndGroup();++ if (value_changed && memcmp(backup_initial_col, col, components * sizeof(float)) == 0)+ value_changed = false;+ if (value_changed && g.LastItemData.ID != 0) // In case of ID collision, the second EndGroup() won't catch g.ActiveId+ MarkItemEdited(g.LastItemData.ID);++ if (set_current_color_edit_id)+ g.ColorEditCurrentID = 0;+ PopID();++ if (g.DisabledStackSize > 0)+ g.Style.Alpha = backup_alpha;++ return value_changed;+}++// A little color square. Return true when clicked.+// FIXME: May want to display/ignore the alpha component in the color display? Yet show it in the tooltip.+// 'desc_id' is not called 'label' because we don't display it next to the button, but only in the tooltip.+// Note that 'col' may be encoded in HSV if ImGuiColorEditFlags_InputHSV is set.+bool ImGui::ColorButton(const char* desc_id, const ImVec4& col, ImGuiColorEditFlags flags, const ImVec2& size_arg)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiID id = window->GetID(desc_id);+ const float default_size = GetFrameHeight();+ const ImVec2 size(size_arg.x == 0.0f ? default_size : size_arg.x, size_arg.y == 0.0f ? default_size : size_arg.y);+ const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);+ ItemSize(bb, (size.y >= default_size) ? g.Style.FramePadding.y : 0.0f);+ if (!ItemAdd(bb, id))+ return false;++ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held);++ if (flags & (ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaOpaque))+ flags &= ~(ImGuiColorEditFlags_AlphaNoBg | ImGuiColorEditFlags_AlphaPreviewHalf);++ ImVec4 col_rgb = col;+ if (flags & ImGuiColorEditFlags_InputHSV)+ ColorConvertHSVtoRGB(col_rgb.x, col_rgb.y, col_rgb.z, col_rgb.x, col_rgb.y, col_rgb.z);++ const ImVec4 col_rgb_without_alpha(col_rgb.x, col_rgb.y, col_rgb.z, 1.0f);+ const float grid_step = ImMin(size.x, size.y) / 2.99f;+ const float rounding = ImMin(g.Style.FrameRounding, grid_step * 0.5f);+ const bool is_mixed = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;++ const float backup_alpha = g.Style.Alpha;+ if (g.DisabledStackSize > 0)+ g.Style.Alpha = g.DisabledAlphaBackup; // Cancel out effect of BeginDisabled() for color swatches.+ if (is_mixed)+ {+ window->DrawList->AddRectFilled(bb.Min, bb.Max, GetColorU32(ImGuiCol_FrameBg), rounding);+ PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextMixedValue]);+ if (g.MixedValueLabel != NULL)+ RenderTextClipped(ImVec2(bb.Min.x, bb.Min.y + g.Style.FramePadding.y), bb.Max, g.MixedValueLabel, NULL, NULL, ImVec2(0.5f, 0.0f));+ PopStyleColor();+ }+ else if (BuiOn()) // BUI: Blender color swatch (swatch_draw: opaque left half, checker under the alpha half)+ {+ const bool opaque = (flags & (ImGuiColorEditFlags_AlphaOpaque | ImGuiColorEditFlags_NoAlpha)) != 0 || (flags & ImGuiColorEditFlags_AlphaNoBg) != 0;+ BKWidgetDraw w = BuiWidget(BK_WIDGET_SWATCH, bb, (g.HoveredId == id) ? BK_WS_HOVER : 0);+ w.color[0] = col_rgb.x; w.color[1] = col_rgb.y; w.color[2] = col_rgb.z; w.color[3] = opaque ? 1.0f : ImSaturate(col_rgb.w);+ const ImGuiItemFlags backup_item_flags = g.CurrentItemFlags; // swatches keep their color when disabled (as above)+ g.CurrentItemFlags &= ~ImGuiItemFlags_Disabled;+ BuiEmit(w);+ g.CurrentItemFlags = backup_item_flags;+ }+ else if ((flags & ImGuiColorEditFlags_AlphaPreviewHalf) && col_rgb.w < 1.0f)+ {+ float mid_x = IM_ROUND((bb.Min.x + bb.Max.x) * 0.5f);+ if ((flags & ImGuiColorEditFlags_AlphaNoBg) == 0)+ RenderColorRectWithAlphaCheckerboard(window->DrawList, ImVec2(bb.Min.x + grid_step, bb.Min.y), bb.Max, ColorConvertFloat4ToU32(col_rgb), g.Style.Alpha, grid_step, ImVec2(-grid_step, 0.0f), rounding, ImDrawFlags_RoundRight);+ else+ window->DrawList->AddRectFilled(ImVec2(bb.Min.x + grid_step, bb.Min.y), bb.Max, GetColorU32(col_rgb), rounding, ImDrawFlags_RoundRight);+ window->DrawList->AddRectFilled(bb.Min, ImVec2(mid_x, bb.Max.y), GetColorU32(col_rgb_without_alpha), rounding, ImDrawFlags_RoundLeft);+ }+ else+ {+ // Because GetColorU32() multiplies by the global style Alpha and we don't want to display a checkerboard if the source code had no alpha+ ImVec4 col_source = (flags & ImGuiColorEditFlags_AlphaOpaque) ? col_rgb_without_alpha : col_rgb;+ if (col_source.w < 1.0f && (flags & ImGuiColorEditFlags_AlphaNoBg) == 0)+ RenderColorRectWithAlphaCheckerboard(window->DrawList, bb.Min, bb.Max, ColorConvertFloat4ToU32(col_source), g.Style.Alpha, grid_step, ImVec2(0.0f, 0.0f), rounding);+ else+ window->DrawList->AddRectFilled(bb.Min, bb.Max, GetColorU32(col_source), rounding);+ }+ if (g.DisabledStackSize > 0)+ g.Style.Alpha = backup_alpha;+ RenderNavCursor(bb, id);+ if ((flags & ImGuiColorEditFlags_NoBorder) == 0 && !(BuiOn() && !is_mixed)) // BUI: the swatch has its outline+ {+ if (g.Style.FrameBorderSize > 0.0f)+ RenderFrameBorder(bb.Min, bb.Max, rounding);+ else+ window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(ImGuiCol_FrameBg), rounding, 1.0f * (float)(int)g.Style._MainScale); // Color buttons are often in need of some sort of border // FIXME-DPI+ }++ // Drag and Drop Source+ // NB: The ActiveId test is merely an optional micro-optimization, BeginDragDropSource() does the same test.+ if (g.ActiveId == id && !(flags & ImGuiColorEditFlags_NoDragDrop) && BeginDragDropSource())+ {+ if (flags & ImGuiColorEditFlags_NoAlpha)+ SetDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_3F, &col_rgb, sizeof(float) * 3, ImGuiCond_Once);+ else+ SetDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_4F, &col_rgb, sizeof(float) * 4, ImGuiCond_Once);+ PushItemFlag(ImGuiItemFlags_MixedValue, false);+ ColorButton(desc_id, col, flags);+ PopItemFlag();+ SameLine();+ TextEx("Color");+ EndDragDropSource();+ }++ // Tooltip+ if (!(flags & ImGuiColorEditFlags_NoTooltip) && hovered && IsItemHovered(ImGuiHoveredFlags_ForTooltip))+ ColorTooltip(desc_id, &col.x, flags & (ImGuiColorEditFlags_InputMask_ | ImGuiColorEditFlags_AlphaMask_));++ return pressed;+}++#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS+// This allowed passing 0 to set default, whereas NewFrame() will assert if one of missing. Abide to old logic.+void ImGui::SetColorEditOptions(ImGuiColorEditFlags flags)+{+ ImGuiContext& g = *GImGui;+ if ((flags & ImGuiColorEditFlags_DisplayMask_) == 0) { flags |= ImGuiColorEditFlags_DefaultOptions_ & ImGuiColorEditFlags_DisplayMask_; }+ if ((flags & ImGuiColorEditFlags_DataTypeMask_) == 0) { flags |= ImGuiColorEditFlags_DefaultOptions_ & ImGuiColorEditFlags_DataTypeMask_; }+ if ((flags & ImGuiColorEditFlags_PickerMask_) == 0) { flags |= ImGuiColorEditFlags_DefaultOptions_ & ImGuiColorEditFlags_PickerMask_; }+ if ((flags & ImGuiColorEditFlags_InputMask_) == 0) { flags |= ImGuiColorEditFlags_DefaultOptions_ & ImGuiColorEditFlags_InputMask_; }+ g.IO.ConfigColorEditFlags = flags;+}+#endif++// Note: only access 3 floats if ImGuiColorEditFlags_NoAlpha flag is set.+void ImGui::ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags)+{+ ImGuiContext& g = *GImGui;++ if (!BeginTooltipEx(ImGuiTooltipFlags_OverridePrevious, ImGuiWindowFlags_None))+ return;+ const char* text_end = text ? FindRenderedTextEnd(text, NULL) : text;+ if (text_end > text)+ {+ TextEx(text, text_end);+ Separator();+ }++ ImVec2 sz(g.FontSize * 3 + g.Style.FramePadding.y * 2, g.FontSize * 3 + g.Style.FramePadding.y * 2);+ ImVec4 cf(col[0], col[1], col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : col[3]);+ int cr = IM_F32_TO_INT8_SAT(col[0]), cg = IM_F32_TO_INT8_SAT(col[1]), cb = IM_F32_TO_INT8_SAT(col[2]), ca = (flags & ImGuiColorEditFlags_NoAlpha) ? 255 : IM_F32_TO_INT8_SAT(col[3]);+ ImGuiColorEditFlags flags_to_forward = ImGuiColorEditFlags_InputMask_ | ImGuiColorEditFlags_AlphaMask_;+ PushItemFlag(ImGuiItemFlags_MixedValue, false);+ ColorButton("##preview", cf, (flags & flags_to_forward) | ImGuiColorEditFlags_NoTooltip, sz);+ PopItemFlag();+ SameLine();+ if ((flags & ImGuiColorEditFlags_InputRGB) || !(flags & ImGuiColorEditFlags_InputMask_))+ {+ if (flags & ImGuiColorEditFlags_NoAlpha)+ Text("#%02X%02X%02X\nR: %d, G: %d, B: %d\n(%.3f, %.3f, %.3f)", cr, cg, cb, cr, cg, cb, col[0], col[1], col[2]);+ else+ Text("#%02X%02X%02X%02X\nR:%d, G:%d, B:%d, A:%d\n(%.3f, %.3f, %.3f, %.3f)", cr, cg, cb, ca, cr, cg, cb, ca, col[0], col[1], col[2], col[3]);+ }+ else if (flags & ImGuiColorEditFlags_InputHSV)+ {+ if (flags & ImGuiColorEditFlags_NoAlpha)+ Text("H: %.3f, S: %.3f, V: %.3f", col[0], col[1], col[2]);+ else+ Text("H: %.3f, S: %.3f, V: %.3f, A: %.3f", col[0], col[1], col[2], col[3]);+ }+ EndTooltip();+}++void ImGui::ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags)+{+ bool allow_opt_inputs = !(flags & ImGuiColorEditFlags_DisplayMask_);+ bool allow_opt_datatype = !(flags & ImGuiColorEditFlags_DataTypeMask_);+ if ((!allow_opt_inputs && !allow_opt_datatype) || !BeginPopup("context"))+ return;++ ImGuiContext& g = *GImGui;+ PushItemFlag(ImGuiItemFlags_NoMarkEdited, true);+ ImGuiColorEditFlags opts = g.IO.ConfigColorEditFlags;+ if (allow_opt_inputs)+ {+ if (RadioButton("RGB", (opts & ImGuiColorEditFlags_DisplayRGB) != 0)) opts = (opts & ~ImGuiColorEditFlags_DisplayMask_) | ImGuiColorEditFlags_DisplayRGB;+ if (RadioButton("HSV", (opts & ImGuiColorEditFlags_DisplayHSV) != 0)) opts = (opts & ~ImGuiColorEditFlags_DisplayMask_) | ImGuiColorEditFlags_DisplayHSV;+ if (RadioButton("Hex", (opts & ImGuiColorEditFlags_DisplayHex) != 0)) opts = (opts & ~ImGuiColorEditFlags_DisplayMask_) | ImGuiColorEditFlags_DisplayHex;+ }+ if (allow_opt_datatype)+ {+ if (allow_opt_inputs) Separator();+ if (RadioButton("0..255", (opts & ImGuiColorEditFlags_Uint8) != 0)) opts = (opts & ~ImGuiColorEditFlags_DataTypeMask_) | ImGuiColorEditFlags_Uint8;+ if (RadioButton("0.00..1.00", (opts & ImGuiColorEditFlags_Float) != 0)) opts = (opts & ~ImGuiColorEditFlags_DataTypeMask_) | ImGuiColorEditFlags_Float;+ }++ if (allow_opt_inputs || allow_opt_datatype)+ Separator();+ if (Button("Copy as..", ImVec2(-1, 0)))+ OpenPopup("Copy");+ if (BeginPopup("Copy"))+ {+ int cr = IM_F32_TO_INT8_SAT(col[0]), cg = IM_F32_TO_INT8_SAT(col[1]), cb = IM_F32_TO_INT8_SAT(col[2]), ca = (flags & ImGuiColorEditFlags_NoAlpha) ? 255 : IM_F32_TO_INT8_SAT(col[3]);+ char buf[64];+ ImFormatString(buf, IM_COUNTOF(buf), "(%.3ff, %.3ff, %.3ff, %.3ff)", col[0], col[1], col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : col[3]);+ if (Selectable(buf))+ SetClipboardText(buf);+ ImFormatString(buf, IM_COUNTOF(buf), "(%d,%d,%d,%d)", cr, cg, cb, ca);+ if (Selectable(buf))+ SetClipboardText(buf);+ ImFormatString(buf, IM_COUNTOF(buf), "#%02X%02X%02X", cr, cg, cb);+ if (Selectable(buf))+ SetClipboardText(buf);+ if (!(flags & ImGuiColorEditFlags_NoAlpha))+ {+ ImFormatString(buf, IM_COUNTOF(buf), "#%02X%02X%02X%02X", cr, cg, cb, ca);+ if (Selectable(buf))+ SetClipboardText(buf);+ }+ EndPopup();+ }++ g.IO.ConfigColorEditFlags = opts;+ PopItemFlag();+ EndPopup();+}++void ImGui::ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags)+{+ bool allow_opt_picker = !(flags & ImGuiColorEditFlags_PickerMask_);+ bool allow_opt_alpha_bar = !(flags & ImGuiColorEditFlags_NoAlpha) && !(flags & ImGuiColorEditFlags_AlphaBar);+ if ((!allow_opt_picker && !allow_opt_alpha_bar) || !BeginPopup("context"))+ return;++ ImGuiContext& g = *GImGui;+ PushItemFlag(ImGuiItemFlags_NoMarkEdited, true);+ if (allow_opt_picker)+ {+ ImVec2 picker_size(g.FontSize * 8, ImMax(g.FontSize * 8 - (GetFrameHeight() + g.Style.ItemInnerSpacing.x), 1.0f)); // FIXME: Picker size copied from main picker function+ PushItemWidth(picker_size.x);+ for (int picker_type = 0; picker_type < 2; picker_type++)+ {+ // Draw small/thumbnail version of each picker type (over an invisible button for selection)+ if (picker_type > 0) Separator();+ PushID(picker_type);+ ImGuiColorEditFlags picker_flags = ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoOptions | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoSidePreview | (flags & ImGuiColorEditFlags_NoAlpha);+ if (picker_type == 0) picker_flags |= ImGuiColorEditFlags_PickerHueBar;+ if (picker_type == 1) picker_flags |= ImGuiColorEditFlags_PickerHueWheel;+ ImVec2 backup_pos = GetCursorScreenPos();+ if (Selectable("##selectable", false, 0, picker_size)) // By default, Selectable() is closing popup+ g.IO.ConfigColorEditFlags = (g.IO.ConfigColorEditFlags & ~ImGuiColorEditFlags_PickerMask_) | (picker_flags & ImGuiColorEditFlags_PickerMask_);+ SetCursorScreenPos(backup_pos);+ ImVec4 previewing_ref_col;+ memcpy(&previewing_ref_col, ref_col, sizeof(float) * ((picker_flags & ImGuiColorEditFlags_NoAlpha) ? 3 : 4));+ ColorPicker4("##previewing_picker", &previewing_ref_col.x, picker_flags);+ PopID();+ }+ PopItemWidth();+ }+ if (allow_opt_alpha_bar)+ {+ if (allow_opt_picker) Separator();+ CheckboxFlags("Alpha Bar", &g.IO.ConfigColorEditFlags, ImGuiColorEditFlags_AlphaBar);+ }+ PopItemFlag();+ EndPopup();+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: TreeNode, CollapsingHeader, etc.+//-------------------------------------------------------------------------+// - TreeNode()+// - TreeNodeV()+// - TreeNodeEx()+// - TreeNodeExV()+// - TreeNodeStoreStackData() [Internal]+// - TreeNodeBehavior() [Internal]+// - TreePush()+// - TreePop()+// - GetTreeNodeToLabelSpacing()+// - SetNextItemOpen()+// - CollapsingHeader()+//-------------------------------------------------------------------------++bool ImGui::TreeNode(const char* str_id, const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ bool is_open = TreeNodeExV(str_id, 0, fmt, args);+ va_end(args);+ return is_open;+}++bool ImGui::TreeNode(const void* ptr_id, const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ bool is_open = TreeNodeExV(ptr_id, 0, fmt, args);+ va_end(args);+ return is_open;+}++bool ImGui::TreeNode(const char* label)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;+ ImGuiID id = window->GetID(label);+ return TreeNodeBehavior(id, ImGuiTreeNodeFlags_None, label, NULL);+}++bool ImGui::TreeNodeV(const char* str_id, const char* fmt, va_list args)+{+ return TreeNodeExV(str_id, 0, fmt, args);+}++bool ImGui::TreeNodeV(const void* ptr_id, const char* fmt, va_list args)+{+ return TreeNodeExV(ptr_id, 0, fmt, args);+}++bool ImGui::TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;+ ImGuiID id = window->GetID(label);+ return TreeNodeBehavior(id, flags, label, NULL);+}++bool ImGui::TreeNodeEx(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ bool is_open = TreeNodeExV(str_id, flags, fmt, args);+ va_end(args);+ return is_open;+}++bool ImGui::TreeNodeEx(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, ...)+{+ va_list args;+ va_start(args, fmt);+ bool is_open = TreeNodeExV(ptr_id, flags, fmt, args);+ va_end(args);+ return is_open;+}++bool ImGui::TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiID id = window->GetID(str_id);+ const char* label, *label_end;+ ImFormatStringToTempBufferV(&label, &label_end, fmt, args);+ return TreeNodeBehavior(id, flags, label, label_end);+}++bool ImGui::TreeNodeExV(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiID id = window->GetID(ptr_id);+ const char* label, *label_end;+ ImFormatStringToTempBufferV(&label, &label_end, fmt, args);+ return TreeNodeBehavior(id, flags, label, label_end);+}++// I would like to design a more feature-full and generic API for this.+// (cc: #3823, #9251, #7553, #6754, #5423, #2958, #2079, #1947, #1131, #722, #9569)+bool ImGui::TreeNodeGetOpen(ImGuiID storage_id, ImGuiTreeNodeFlags flags)+{+ if (flags & ImGuiTreeNodeFlags_Leaf)+ return true;+ ImGuiContext& g = *GImGui;+ ImGuiStorage* storage = g.CurrentWindow->DC.StateStorage;+ return storage->GetInt(storage_id, (flags & ImGuiTreeNodeFlags_DefaultOpen) ? 1 : 0) != 0;+}++void ImGui::TreeNodeSetOpen(ImGuiID storage_id, bool is_open)+{+ ImGuiContext& g = *GImGui;+ ImGuiStorage* storage = g.CurrentWindow->DC.StateStorage;+ storage->SetInt(storage_id, is_open ? 1 : 0);+}++bool ImGui::TreeNodeUpdateNextOpen(ImGuiID storage_id, ImGuiTreeNodeFlags flags)+{+ // Leaf node always open a new tree/id scope. If you never use it, add ImGuiTreeNodeFlags_NoTreePushOnOpen.+ if (flags & ImGuiTreeNodeFlags_Leaf)+ return true;++ // We only write to the tree storage if the user clicks, or explicitly use the SetNextItemOpen function+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ ImGuiStorage* storage = window->DC.StateStorage;++ bool is_open;+ if (g.NextItemData.HasFlags & ImGuiNextItemDataFlags_HasOpen)+ {+ if (g.NextItemData.OpenCond & ImGuiCond_Always)+ {+ is_open = g.NextItemData.OpenVal;+ TreeNodeSetOpen(storage_id, is_open);+ }+ else+ {+ // We treat ImGuiCond_Once and ImGuiCond_FirstUseEver the same because tree node state are not saved persistently.+ const int stored_value = storage->GetInt(storage_id, -1);+ if (stored_value == -1)+ {+ is_open = g.NextItemData.OpenVal;+ TreeNodeSetOpen(storage_id, is_open);+ }+ else+ {+ is_open = stored_value != 0;+ }+ }+ }+ else+ {+ is_open = storage->GetInt(storage_id, (flags & ImGuiTreeNodeFlags_DefaultOpen) ? 1 : 0) != 0;+ }++ // When logging is enabled, we automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behavior).+ // NB- If we are above max depth we still allow manually opened nodes to be logged.+ if (g.LogEnabled && !(flags & ImGuiTreeNodeFlags_NoAutoOpenOnLog) && (window->DC.TreeDepth - g.LogDepthRef) < g.LogDepthToExpand)+ is_open = true;++ return is_open;+}++// Store ImGuiTreeNodeStackData for just submitted node.+// Currently only supports 32 level deep. Easy to increase to e.g. 64.+static void TreeNodeStoreStackData(ImGuiTreeNodeFlags flags, float x1)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ g.TreeNodeStack.resize(g.TreeNodeStack.Size + 1);+ ImGuiTreeNodeStackData* tree_node_data = &g.TreeNodeStack.Data[g.TreeNodeStack.Size - 1];+ tree_node_data->ID = g.LastItemData.ID;+ tree_node_data->TreeFlags = flags;+ tree_node_data->ItemFlags = g.LastItemData.ItemFlags;+ tree_node_data->NavRect = g.LastItemData.NavRect;++ // Initially I tried to latch value for GetColorU32(ImGuiCol_TreeLines) but it's not a good trade-off for very large trees.+ const bool draw_lines = (flags & (ImGuiTreeNodeFlags_DrawLinesFull | ImGuiTreeNodeFlags_DrawLinesToNodes)) != 0;+ tree_node_data->DrawLinesX1 = draw_lines ? (x1 + g.FontSize * 0.5f + g.Style.FramePadding.x) : +FLT_MAX;+ tree_node_data->DrawLinesTableColumn = (draw_lines && g.CurrentTable) ? (ImGuiTableColumnIdx)g.CurrentTable->CurrentColumn : -1;+ tree_node_data->DrawLinesToNodesY2 = -FLT_MAX;+ window->DC.TreeHasStackDataDepthMask |= (1 << window->DC.TreeDepth);+ if (flags & ImGuiTreeNodeFlags_DrawLinesToNodes)+ window->DC.TreeRecordsClippedNodesY2Mask |= (1 << window->DC.TreeDepth);+}++#define TREE_NODE_MAX_DEPTH 32+#define TREE_NODE_GET_DEPTH_MASK(_DEPTH) (((ImU32)(_DEPTH) < TREE_NODE_MAX_DEPTH) ? (1u << (_DEPTH)) : 0u)++bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;++ // When not framed, we vertically increase height up to typical framed widget height+ const bool display_frame = (flags & ImGuiTreeNodeFlags_Framed) != 0;+ const bool use_frame_padding = (display_frame || (flags & ImGuiTreeNodeFlags_FramePadding));+ const ImVec2 padding = use_frame_padding ? style.FramePadding : ImVec2(style.FramePadding.x, ImMin(window->DC.CurrLineTextBaseOffset, style.FramePadding.y));++ if (!label_end)+ label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);++ const float icon_width = g.FontSize + padding.x * 2;+ const float text_offset_x = display_frame ? icon_width + padding.x : icon_width; // Collapsing arrow width + Spacing+ const float text_offset_y = use_frame_padding ? ImMax(style.FramePadding.y, window->DC.CurrLineTextBaseOffset) : window->DC.CurrLineTextBaseOffset; // Latch before ItemSize changes it+ const float text_width = icon_width + label_size.x; // Include collapsing arrow++ const float frame_height = label_size.y + padding.y * 2;+ const bool span_all_columns = (flags & ImGuiTreeNodeFlags_SpanAllColumns) != 0 && (g.CurrentTable != NULL);+ const bool span_all_columns_label = (flags & ImGuiTreeNodeFlags_LabelSpanAllColumns) != 0 && (g.CurrentTable != NULL);+ ImRect frame_bb;+ frame_bb.Min.x = span_all_columns ? window->ParentWorkRect.Min.x : (flags & ImGuiTreeNodeFlags_SpanFullWidth) ? window->WorkRect.Min.x : window->DC.CursorPos.x;+ frame_bb.Min.y = window->DC.CursorPos.y + (text_offset_y - padding.y);+ frame_bb.Max.x = span_all_columns ? window->ParentWorkRect.Max.x : (flags & ImGuiTreeNodeFlags_SpanLabelWidth) ? window->DC.CursorPos.x + text_width + padding.x : window->WorkRect.Max.x;+ frame_bb.Max.y = window->DC.CursorPos.y + (text_offset_y - padding.y) + frame_height;+ if (display_frame)+ {+ const float outer_extend = IM_TRUNC(window->WindowPadding.x * 0.5f); // Framed header expand a little outside of current limits+ frame_bb.Min.x -= outer_extend;+ frame_bb.Max.x += outer_extend;+ }++ ImVec2 text_pos(window->DC.CursorPos.x + text_offset_x, window->DC.CursorPos.y + text_offset_y);+ ItemSize(ImVec2(text_width, frame_height), padding.y);++ // For regular tree nodes, we arbitrary allow to click past 2 worth of ItemSpacing+ ImRect interact_bb = frame_bb;+ if ((flags & (ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_SpanLabelWidth | ImGuiTreeNodeFlags_SpanAllColumns)) == 0)+ interact_bb.Max.x = frame_bb.Min.x + text_width + (label_size.x > 0.0f ? style.ItemSpacing.x * 2.0f : 0.0f);++ // Compute open and multi-select states before ItemAdd() as it clear NextItem data.+ ImGuiID storage_id = (g.NextItemData.HasFlags & ImGuiNextItemDataFlags_HasStorageID) ? g.NextItemData.StorageId : id;+ bool is_open = TreeNodeUpdateNextOpen(storage_id, flags);++ bool is_visible;+ if (span_all_columns || span_all_columns_label)+ {+ // Modify ClipRect for the ItemAdd(), faster than doing a PushColumnsBackground/PushTableBackgroundChannel for every Selectable..+ // FIXME: Investigate moving this to an item flag, along duplicate code in Selectable(). How to do optimally?+ const float backup_clip_rect_min_x = window->ClipRect.Min.x;+ const float backup_clip_rect_max_x = window->ClipRect.Max.x;+ window->ClipRect.Min.x = window->ParentWorkRect.Min.x;+ window->ClipRect.Max.x = window->ParentWorkRect.Max.x;+ is_visible = ItemAdd(interact_bb, id);+ window->ClipRect.Min.x = backup_clip_rect_min_x;+ window->ClipRect.Max.x = backup_clip_rect_max_x;+ }+ else+ {+ is_visible = ItemAdd(interact_bb, id);+ }+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasDisplayRect;+ g.LastItemData.DisplayRect = frame_bb;++ // If a NavLeft request is happening and ImGuiTreeNodeFlags_NavLeftJumpsToParent enabled:+ // Store data for the current depth to allow returning to this node from any child item.+ // For this purpose we essentially compare if g.NavIdIsAlive went from 0 to 1 between TreeNode() and TreePop().+ // It will become tempting to enable ImGuiTreeNodeFlags_NavLeftJumpsToParent by default or move it to ImGuiStyle.+ bool store_tree_node_stack_data = false;+ if ((flags & ImGuiTreeNodeFlags_DrawLinesMask_) == 0)+ flags |= g.Style.TreeLinesFlags;+ const bool draw_tree_lines = (flags & (ImGuiTreeNodeFlags_DrawLinesFull | ImGuiTreeNodeFlags_DrawLinesToNodes)) && (frame_bb.Min.y < window->ClipRect.Max.y) && (g.Style.TreeLinesSize > 0.0f);+ if (!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen) && window->DC.TreeDepth < TREE_NODE_MAX_DEPTH)+ {+ store_tree_node_stack_data = draw_tree_lines;+ if ((flags & ImGuiTreeNodeFlags_NavLeftJumpsToParent) && !g.NavIdIsAlive)+ if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window && NavMoveRequestButNoResultYet())+ store_tree_node_stack_data = true;+ }++ const bool is_leaf = (flags & ImGuiTreeNodeFlags_Leaf) != 0;+ if (!is_visible)+ {+ if (flags & ImGuiTreeNodeFlags_DrawLinesToNodes)+ {+ const ImU32 tree_depth_mask = TREE_NODE_GET_DEPTH_MASK(window->DC.TreeDepth - 1);+ if (window->DC.TreeRecordsClippedNodesY2Mask & tree_depth_mask)+ {+ ImGuiTreeNodeStackData* parent_data = &g.TreeNodeStack.Data[g.TreeNodeStack.Size - 1];+ parent_data->DrawLinesToNodesY2 = ImMax(parent_data->DrawLinesToNodesY2, window->DC.CursorPos.y); // Don't need to aim to mid Y position as we are clipped anyway.+ if (frame_bb.Min.y >= window->ClipRect.Max.y)+ window->DC.TreeRecordsClippedNodesY2Mask &= ~tree_depth_mask; // Done+ }+ }+ if (is_open && store_tree_node_stack_data)+ TreeNodeStoreStackData(flags, text_pos.x - text_offset_x); // Call before TreePushOverrideID()+ if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))+ TreePushOverrideID(id);+ IMGUI_TEST_ENGINE_ITEM_INFO(g.LastItemData.ID, label, g.LastItemData.StatusFlags | (is_leaf ? 0 : ImGuiItemStatusFlags_Openable) | (is_open ? ImGuiItemStatusFlags_Opened : 0));+ return is_open;+ }++ if (span_all_columns || span_all_columns_label)+ {+ TablePushBackgroundChannel();+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasClipRect;+ g.LastItemData.ClipRect = window->ClipRect;+ }++ ImGuiButtonFlags button_flags = ImGuiTreeNodeFlags_None;+ if ((flags & ImGuiTreeNodeFlags_AllowOverlap) || (g.LastItemData.ItemFlags & ImGuiItemFlags_AllowOverlap))+ button_flags |= ImGuiButtonFlags_AllowOverlap;+ if (!is_leaf)+ button_flags |= ImGuiButtonFlags_PressedOnDragDropHold;++ // We allow clicking on the arrow section with keyboard modifiers held, in order to easily+ // allow browsing a tree while preserving selection with code implementing multi-selection patterns.+ // When clicking on the rest of the tree node we always disallow keyboard modifiers.+ const float arrow_hit_x1 = (text_pos.x - text_offset_x) - style.TouchExtraPadding.x;+ const float arrow_hit_x2 = (text_pos.x - text_offset_x) + (g.FontSize + padding.x * 2.0f) + style.TouchExtraPadding.x;+ const bool is_mouse_x_over_arrow = (g.IO.MousePos.x >= arrow_hit_x1 && g.IO.MousePos.x < arrow_hit_x2);++ const bool is_multi_select = (g.LastItemData.ItemFlags & ImGuiItemFlags_IsMultiSelect) != 0;+ if (is_multi_select) // We absolutely need to distinguish open vs select so _OpenOnArrow comes by default+ flags |= (flags & ImGuiTreeNodeFlags_OpenOnMask_) == 0 ? ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick : ImGuiTreeNodeFlags_OpenOnArrow;++ // Open behaviors can be altered with the _OpenOnArrow and _OnOnDoubleClick flags.+ // Some alteration have subtle effects (e.g. toggle on MouseUp vs MouseDown events) due to requirements for multi-selection and drag and drop support.+ // - Single-click on label = Toggle on MouseUp (default, when _OpenOnArrow=0)+ // - Single-click on arrow = Toggle on MouseDown (when _OpenOnArrow=0)+ // - Single-click on arrow = Toggle on MouseDown (when _OpenOnArrow=1)+ // - Double-click on label = Toggle on MouseDoubleClick (when _OpenOnDoubleClick=1)+ // - Double-click on arrow = Toggle on MouseDoubleClick (when _OpenOnDoubleClick=1 and _OpenOnArrow=0)+ // It is rather standard that arrow click react on Down rather than Up.+ // We set ImGuiButtonFlags_PressedOnClickRelease on OpenOnDoubleClick because we want the item to be active on the initial MouseDown in order for drag and drop to work.+ if (is_mouse_x_over_arrow)+ button_flags |= ImGuiButtonFlags_PressedOnClick;+ else if (flags & ImGuiTreeNodeFlags_OpenOnDoubleClick)+ button_flags |= ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnDoubleClick;+ else+ button_flags |= ImGuiButtonFlags_PressedOnClickRelease;+ if (flags & ImGuiTreeNodeFlags_NoNavFocus)+ button_flags |= ImGuiButtonFlags_NoNavFocus;++ bool selected = (flags & ImGuiTreeNodeFlags_Selected) != 0;+ const bool was_selected = selected;++ // Multi-selection support (header)+ if (is_multi_select)+ {+ // Handle multi-select + alter button flags for it+ MultiSelectItemHeader(id, &selected, &button_flags);+ if (is_mouse_x_over_arrow)+ button_flags = (button_flags | ImGuiButtonFlags_PressedOnClick) & ~ImGuiButtonFlags_PressedOnClickRelease;+ }+ else+ {+ if (window != g.HoveredWindow || !is_mouse_x_over_arrow)+ button_flags |= ImGuiButtonFlags_NoKeyModsAllowed;+ }++ bool hovered, held;+ bool pressed = ButtonBehavior(interact_bb, id, &hovered, &held, button_flags);+ bool toggled = false;+ if (!is_leaf)+ {+ if (pressed && g.DragDropHoldJustPressedId != id)+ {+ if ((flags & ImGuiTreeNodeFlags_OpenOnMask_) == 0 || (g.NavActivateId == id && !is_multi_select))+ toggled = true; // Single click+ if (flags & ImGuiTreeNodeFlags_OpenOnArrow)+ toggled |= is_mouse_x_over_arrow && !g.NavHighlightItemUnderNav; // Lightweight equivalent of IsMouseHoveringRect() since ButtonBehavior() already did the job+ if ((flags & ImGuiTreeNodeFlags_OpenOnDoubleClick) && g.IO.MouseClickedCount[0] == 2)+ toggled = true; // Double click+ }+ else if (pressed && g.DragDropHoldJustPressedId == id)+ {+ IM_ASSERT(button_flags & ImGuiButtonFlags_PressedOnDragDropHold);+ if (!is_open) // When using Drag and Drop "hold to open" we keep the node highlighted after opening, but never close it again.+ toggled = true;+ else+ pressed = false; // Cancel press so it doesn't trigger selection.+ }++ if (g.NavId == id && g.NavMoveDir == ImGuiDir_Left && is_open)+ {+ toggled = true;+ NavClearPreferredPosForAxis(ImGuiAxis_X);+ NavMoveRequestCancel();+ }+ if (g.NavId == id && g.NavMoveDir == ImGuiDir_Right && !is_open) // If there's something upcoming on the line we may want to give it the priority?+ {+ toggled = true;+ NavClearPreferredPosForAxis(ImGuiAxis_X);+ NavMoveRequestCancel();+ }++ if (toggled)+ {+ is_open = !is_open;+ window->DC.StateStorage->SetInt(storage_id, is_open);+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_ToggledOpen;+ }+ }++ // Multi-selection support (footer)+ if (is_multi_select)+ {+ bool pressed_copy = pressed && !toggled;+ MultiSelectItemFooter(id, &selected, &pressed_copy);+ if (pressed)+ SetNavID(id, window->DC.NavLayerCurrent, g.CurrentFocusScopeId, interact_bb);+ }++ if (selected != was_selected)+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_ToggledSelection;++ // Render+ {+ const ImU32 text_col = GetColorU32(ImGuiCol_Text);+ ImGuiNavRenderCursorFlags nav_render_cursor_flags = ImGuiNavRenderCursorFlags_Compact;+ if (is_multi_select)+ nav_render_cursor_flags |= ImGuiNavRenderCursorFlags_AlwaysDraw; // Always show the nav rectangle+ bool bui_label_done = false;+ if (BuiOn() && display_frame && !(flags & ImGuiTreeNodeFlags_Bullet)) // BUI: Blender panel header (panel_draw: arrow icon, title)+ {+ const bool kit_text = BuiTextOk() && !is_leaf;+ BKWidgetDraw w = BuiWidget(BK_WIDGET_PANEL_HEADER, frame_bb, (hovered ? BK_WS_HOVER : 0) | (is_open ? BK_WS_OPEN : 0));+ if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)+ BuiSetTextRect(w, frame_bb.Min, frame_bb.GetWidth() - g.FontSize - style.FramePadding.x, frame_bb.GetHeight());+ if (is_leaf)+ w.state |= BK_WS_FLAT; // (no arrow: drawn as the header alone)+ BuiEmit(w, kit_text ? label : NULL, label_end);+ RenderNavCursor(frame_bb, id, nav_render_cursor_flags);+ if (span_all_columns && !span_all_columns_label)+ TablePopBackgroundChannel();+ if (is_leaf)+ text_pos.x -= text_offset_x - padding.x;+ if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)+ frame_bb.Max.x -= g.FontSize + style.FramePadding.x;+ bui_label_done = kit_text;+ if (kit_text && g.LogEnabled)+ LogRenderedText(&text_pos, label, label_end);+ }+ else if (BuiOn() && !display_frame) // BUI: Blender tree row (tree_draw_row: list-item highlight, disclosure triangle)+ {+ BKWidgetDraw w = BuiWidget(BK_WIDGET_DISCLOSURE, frame_bb, (hovered ? BK_WS_HOVER : 0) | (selected ? BK_WS_SELECTED : 0) | (is_open ? BK_WS_OPEN : 0));+ if (!is_leaf && !(flags & ImGuiTreeNodeFlags_Bullet))+ w.aux[0] = text_pos.x - text_offset_x + padding.x + g.FontSize * 0.5f;+ BuiEmit(w);+ RenderNavCursor(frame_bb, id, nav_render_cursor_flags, 0.0f);+ if (span_all_columns && !span_all_columns_label)+ TablePopBackgroundChannel();+ if (flags & ImGuiTreeNodeFlags_Bullet)+ RenderBullet(window->DrawList, ImVec2(text_pos.x - text_offset_x * 0.5f, text_pos.y + g.FontSize * 0.5f), text_col);+ if (g.LogEnabled)+ LogSetNextTextDecoration(">", NULL);+ }+ else if (display_frame) // BUI+ {+ // Framed type+ const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);+ RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, true, style.FrameRounding);+ RenderNavCursor(frame_bb, id, nav_render_cursor_flags);+ if (span_all_columns && !span_all_columns_label)+ TablePopBackgroundChannel();+ if (flags & ImGuiTreeNodeFlags_Bullet)+ RenderBullet(window->DrawList, ImVec2(text_pos.x - text_offset_x * 0.60f, text_pos.y + g.FontSize * 0.5f), text_col);+ else if (!is_leaf)+ RenderArrow(window->DrawList, ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y), text_col, is_open ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up : ImGuiDir_Down) : ImGuiDir_Right, 1.0f);+ else // Leaf without bullet, left-adjusted text+ text_pos.x -= text_offset_x - padding.x;+ if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)+ frame_bb.Max.x -= g.FontSize + style.FramePadding.x;+ if (g.LogEnabled)+ LogSetNextTextDecoration("###", "###");+ }+ else+ {+ // Unframed typed for tree nodes+ if (hovered || selected)+ {+ const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);+ RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, false, 0.0f);+ }+ RenderNavCursor(frame_bb, id, nav_render_cursor_flags, 0.0f);+ if (span_all_columns && !span_all_columns_label)+ TablePopBackgroundChannel();+ if (flags & ImGuiTreeNodeFlags_Bullet)+ RenderBullet(window->DrawList, ImVec2(text_pos.x - text_offset_x * 0.5f, text_pos.y + g.FontSize * 0.5f), text_col);+ else if (!is_leaf)+ RenderArrow(window->DrawList, ImVec2(text_pos.x + g.FontSize * 0.15f - text_offset_x + padding.x, text_pos.y + g.FontSize * 0.15f), text_col, is_open ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up : ImGuiDir_Down) : ImGuiDir_Right, 0.70f);+ if (g.LogEnabled)+ LogSetNextTextDecoration(">", NULL);+ }++ if (draw_tree_lines)+ TreeNodeDrawLineToChildNode(ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y + g.FontSize * 0.5f));++ // Label+ if (bui_label_done) // BUI: drawn by the kit+ {}+ else if (display_frame)+ RenderTextClipped(text_pos, frame_bb.Max, label, label_end, &label_size);+ else+ RenderText(text_pos, label, label_end, false);++ if (span_all_columns_label)+ TablePopBackgroundChannel();+ }++ if (is_open && store_tree_node_stack_data)+ TreeNodeStoreStackData(flags, text_pos.x - text_offset_x); // Call before TreePushOverrideID()+ if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))+ TreePushOverrideID(id); // Could use TreePush(label) but this avoid computing twice++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | (is_leaf ? 0 : ImGuiItemStatusFlags_Openable) | (is_open ? ImGuiItemStatusFlags_Opened : 0));+ return is_open;+}++// Draw horizontal line from our parent node+// This is only called for visible child nodes so we are not too fussy anymore about performances+void ImGui::TreeNodeDrawLineToChildNode(const ImVec2& target_pos)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if ((window->DC.TreeHasStackDataDepthMask & TREE_NODE_GET_DEPTH_MASK(window->DC.TreeDepth - 1)) == 0)+ return;++ // FIXME: Could this be simplified using new stroke flags?+ ImGuiTreeNodeStackData* parent_data = &g.TreeNodeStack.Data[g.TreeNodeStack.Size - 1];+ const float half_size = g.Style.TreeLinesSize * 0.5f;+ float x1 = ImTrunc(parent_data->DrawLinesX1 - half_size) + half_size; // Draw line centered at X1, but snap to pixels boundary.+ float x2 = ImTrunc(target_pos.x - g.Style.ItemInnerSpacing.x);+ float y = ImTrunc(target_pos.y - half_size) + half_size;+ float rounding = (g.Style.TreeLinesRounding > 0.0f) ? ImMin(x2 - x1, g.Style.TreeLinesRounding) : 0.0f;+ parent_data->DrawLinesToNodesY2 = ImMax(parent_data->DrawLinesToNodesY2, y - rounding);+ if (x1 >= x2)+ return;+ if (rounding > 0.0f && rounding > half_size)+ {+ x1 += rounding;+ window->DrawList->PathArcToFast(ImVec2(x1, y - rounding), rounding, 6, 3);+ if (x1 < x2)+ window->DrawList->PathLineTo(ImVec2(x2, y));+ window->DrawList->PathStroke(GetColorU32(ImGuiCol_TreeLines), g.Style.TreeLinesSize);+ }+ else+ {+ // We use AddLine() instead of AddLineH() as we provide coordinates for line center,+ // in order to make the code use same coordinates for both rounded and non-rounded version. (FIXME-OPT)+ x1 += half_size; // Avoid overdraw+ window->DrawList->AddLine(ImVec2(x1, y), ImVec2(x2, y), GetColorU32(ImGuiCol_TreeLines), g.Style.TreeLinesSize);+ }+}++// Draw vertical line of the hierarchy+void ImGui::TreeNodeDrawLineToTreePop(const ImGuiTreeNodeStackData* data)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ float y1 = ImMax(data->NavRect.Max.y, window->ClipRect.Min.y);+ float y2 = data->DrawLinesToNodesY2;+ if (data->TreeFlags & ImGuiTreeNodeFlags_DrawLinesFull)+ {+ float y2_full = window->DC.CursorPos.y;+ if (g.CurrentTable)+ y2_full = ImMax(g.CurrentTable->RowPosY2, y2_full);+ y2_full = ImTrunc(y2_full - g.Style.ItemSpacing.y - g.FontSize * 0.5f);+ if (y2 + (g.Style.ItemSpacing.y + g.Style.TreeLinesRounding) < y2_full) // FIXME: threshold to use ToNodes Y2 instead of Full Y2 when close by ItemSpacing.y+ y2 = y2_full;+ }+ y2 = ImMin(y2, window->ClipRect.Max.y);+ if (y2 <= y1)+ return;+ float x = ImTrunc(data->DrawLinesX1 - g.Style.TreeLinesSize * 0.5f) + g.Style.TreeLinesSize * 0.5f; // Draw line centered at X1, but snap to pixels boundary.+ if (data->DrawLinesTableColumn != -1)+ TablePushColumnChannel(data->DrawLinesTableColumn);++ // We use AddLine() instead of AddLineV() as we provide coordinates for line center (FIXME-OPT)+ window->DrawList->AddLine(ImVec2(x, y1), ImVec2(x, y2), GetColorU32(ImGuiCol_TreeLines), g.Style.TreeLinesSize);+ if (data->DrawLinesTableColumn != -1)+ TablePopColumnChannel();+}++void ImGui::TreePush(const char* str_id)+{+ ImGuiWindow* window = GetCurrentWindow();+ Indent();+ window->DC.TreeDepth++;+ PushID(str_id);+}++void ImGui::TreePush(const void* ptr_id)+{+ ImGuiWindow* window = GetCurrentWindow();+ Indent();+ window->DC.TreeDepth++;+ PushID(ptr_id);+}++void ImGui::TreePushOverrideID(ImGuiID id)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ Indent();+ window->DC.TreeDepth++;+ PushOverrideID(id);+}++void ImGui::TreePop()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ Unindent();++ window->DC.TreeDepth--;+ ImU32 tree_depth_mask = TREE_NODE_GET_DEPTH_MASK(window->DC.TreeDepth);+ if (window->DC.TreeHasStackDataDepthMask & tree_depth_mask)+ {+ const ImGuiTreeNodeStackData* data = &g.TreeNodeStack.Data[g.TreeNodeStack.Size - 1];+ IM_ASSERT(data->ID == window->IDStack.back());++ // Handle Left arrow to move to parent tree node (when ImGuiTreeNodeFlags_NavLeftJumpsToParent is enabled)+ if (data->TreeFlags & ImGuiTreeNodeFlags_NavLeftJumpsToParent)+ if (g.NavIdIsAlive && g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window && NavMoveRequestButNoResultYet())+ NavMoveRequestResolveWithPastTreeNode(&g.NavMoveResultLocal, data);++ // Draw hierarchy lines+ if (data->DrawLinesX1 != +FLT_MAX && window->DC.CursorPos.y >= window->ClipRect.Min.y)+ TreeNodeDrawLineToTreePop(data);++ g.TreeNodeStack.pop_back();+ window->DC.TreeHasStackDataDepthMask &= ~tree_depth_mask;+ window->DC.TreeRecordsClippedNodesY2Mask &= ~tree_depth_mask;+ }++ IM_ASSERT(window->IDStack.Size > 1); // There should always be 1 element in the IDStack (pushed during window creation). If this triggers you called TreePop/PopID too much.+ PopID();+}++// Horizontal distance preceding label when using TreeNode() or Bullet()+float ImGui::GetTreeNodeToLabelSpacing()+{+ ImGuiContext& g = *GImGui;+ return g.FontSize + (g.Style.FramePadding.x * 2.0f);+}++// Set next TreeNode/CollapsingHeader open state.+void ImGui::SetNextItemOpen(bool is_open, ImGuiCond cond)+{+ ImGuiContext& g = *GImGui;+ if (g.CurrentWindow->SkipItems)+ return;+ g.NextItemData.HasFlags |= ImGuiNextItemDataFlags_HasOpen;+ g.NextItemData.OpenVal = is_open;+ g.NextItemData.OpenCond = (ImU8)(cond ? cond : ImGuiCond_Always);+}++// Set next TreeNode/CollapsingHeader storage id.+void ImGui::SetNextItemStorageID(ImGuiID storage_id)+{+ ImGuiContext& g = *GImGui;+ if (g.CurrentWindow->SkipItems)+ return;+ g.NextItemData.HasFlags |= ImGuiNextItemDataFlags_HasStorageID;+ g.NextItemData.StorageId = storage_id;+}++// CollapsingHeader returns true when opened but do not indent nor push into the ID stack (because of the ImGuiTreeNodeFlags_NoTreePushOnOpen flag).+// This is basically the same as calling TreeNodeEx(label, ImGuiTreeNodeFlags_CollapsingHeader). You can remove the _NoTreePushOnOpen flag if you want behavior closer to normal TreeNode().+bool ImGui::CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;+ ImGuiID id = window->GetID(label);+ return TreeNodeBehavior(id, flags | ImGuiTreeNodeFlags_CollapsingHeader, label);+}++// p_visible == NULL : regular collapsing header+// p_visible != NULL && *p_visible == true : show a small close button on the corner of the header, clicking the button will set *p_visible = false+// p_visible != NULL && *p_visible == false : do not show the header at all+// Do not mistake this with the Open state of the header itself, which you can adjust with SetNextItemOpen() or ImGuiTreeNodeFlags_DefaultOpen.+bool ImGui::CollapsingHeader(const char* label, bool* p_visible, ImGuiTreeNodeFlags flags)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ if (p_visible && !*p_visible)+ return false;++ ImGuiID id = window->GetID(label);+ flags |= ImGuiTreeNodeFlags_CollapsingHeader;+ if (p_visible)+ flags |= ImGuiTreeNodeFlags_AllowOverlap | (ImGuiTreeNodeFlags)ImGuiTreeNodeFlags_ClipLabelForTrailingButton;+ bool is_open = TreeNodeBehavior(id, flags, label);+ if (p_visible != NULL)+ {+ // Create a small overlapping close button+ // FIXME: We can evolve this into user accessible helpers to add extra buttons on title bars, headers, etc.+ // FIXME: CloseButton can overlap into text, need find a way to clip the text somehow.+ ImGuiContext& g = *GImGui;+ ImGuiLastItemData last_item_backup = g.LastItemData;+ float button_size = g.FontSize;+ float button_x = ImMax(g.LastItemData.Rect.Min.x, g.LastItemData.Rect.Max.x - g.Style.FramePadding.x - button_size);+ float button_y = g.LastItemData.Rect.Min.y + g.Style.FramePadding.y;+ ImGuiID close_button_id = GetIDWithSeed("#CLOSE", NULL, id);+ if (CloseButton(close_button_id, ImVec2(button_x, button_y)))+ *p_visible = false;+ g.LastItemData = last_item_backup;+ }++ return is_open;+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: Selectable+//-------------------------------------------------------------------------+// - Selectable()+//-------------------------------------------------------------------------++// Tip: pass a non-visible label (e.g. "##hello") then you can use the space to draw other text or image.+// But you need to make sure the ID is unique, e.g. enclose calls in PushID/PopID or use ##unique_id.+// With this scheme, ImGuiSelectableFlags_SpanAllColumns and ImGuiSelectableFlags_AllowOverlap are also frequently used flags.+// FIXME: Selectable() with (size.x == 0.0f) and (SelectableTextAlign.x > 0.0f) followed by SameLine() is currently not supported.+bool ImGui::Selectable(const char* label, bool selected, ImGuiSelectableFlags flags, const ImVec2& size_arg)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ const ImGuiStyle& style = g.Style;++ // Submit label or explicit size to ItemSize(), whereas ItemAdd() will submit a larger/spanning rectangle.+ ImGuiID id = window->GetID(label);+ const char* label_end = FindRenderedTextEnd(label);+ ImVec2 label_size = CalcTextSize(label, label_end, false);+ ImVec2 size(size_arg.x != 0.0f ? size_arg.x : label_size.x, size_arg.y != 0.0f ? size_arg.y : label_size.y);+ ImVec2 pos = window->DC.CursorPos;+ pos.y += window->DC.CurrLineTextBaseOffset;+ ItemSize(size, 0.0f);++ // Fill horizontal space+ // We don't support (size < 0.0f) in Selectable() because the ItemSpacing extension would make explicitly right-aligned sizes not visibly match other widgets.+ const bool span_all_columns = (flags & ImGuiSelectableFlags_SpanAllColumns) != 0;+ const float min_x = span_all_columns ? window->ParentWorkRect.Min.x : pos.x;+ const float max_x = span_all_columns ? window->ParentWorkRect.Max.x : window->WorkRect.Max.x;+ if (size_arg.x == 0.0f || (flags & ImGuiSelectableFlags_SpanAvailWidth))+ size.x = ImMax(label_size.x, max_x - min_x);++ // Selectables are meant to be tightly packed together with no click-gap, so we extend their box to cover spacing between selectable.+ // FIXME: Not part of layout so not included in clipper calculation, but ItemSize currently doesn't allow offsetting CursorPos.+ ImRect bb(min_x, pos.y, min_x + size.x, pos.y + size.y);+ if ((flags & ImGuiSelectableFlags_NoPadWithHalfSpacing) == 0)+ {+ const float spacing_x = span_all_columns ? 0.0f : style.ItemSpacing.x;+ const float spacing_y = style.ItemSpacing.y;+ const float spacing_L = IM_TRUNC(spacing_x * 0.50f);+ const float spacing_U = IM_TRUNC(spacing_y * 0.50f);+ bb.Min.x -= spacing_L;+ bb.Min.y -= spacing_U;+ bb.Max.x += (spacing_x - spacing_L);+ bb.Max.y += (spacing_y - spacing_U);+ }+ //if (g.IO.KeyCtrl) { GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(0, 255, 0, 255)); }++ const bool disabled_item = (flags & ImGuiSelectableFlags_Disabled) != 0;+ const ImGuiItemFlags extra_item_flags = disabled_item ? (ImGuiItemFlags)ImGuiItemFlags_Disabled : ImGuiItemFlags_None;+ bool is_visible;+ if (span_all_columns)+ {+ // Modify ClipRect for the ItemAdd(), faster than doing a PushColumnsBackground/PushTableBackgroundChannel for every Selectable..+ const float backup_clip_rect_min_x = window->ClipRect.Min.x;+ const float backup_clip_rect_max_x = window->ClipRect.Max.x;+ window->ClipRect.Min.x = window->ParentWorkRect.Min.x;+ window->ClipRect.Max.x = window->ParentWorkRect.Max.x;+ is_visible = ItemAdd(bb, id, NULL, extra_item_flags);+ window->ClipRect.Min.x = backup_clip_rect_min_x;+ window->ClipRect.Max.x = backup_clip_rect_max_x;+ }+ else+ {+ is_visible = ItemAdd(bb, id, NULL, extra_item_flags);+ }++ const bool is_multi_select = (g.LastItemData.ItemFlags & ImGuiItemFlags_IsMultiSelect) != 0;+ if (!is_visible)+ if (!is_multi_select || !g.BoxSelectState.UnclipMode || !g.BoxSelectState.UnclipRect.Overlaps(bb)) // Extra layer of "no logic clip" for box-select support (would be more overhead to add to ItemAdd)+ return false;++ const bool disabled_global = (g.CurrentItemFlags & ImGuiItemFlags_Disabled) != 0;+ if (disabled_item && !disabled_global) // Only testing this as an optimization+ BeginDisabled();++ // FIXME: We can standardize the behavior of those two, we could also keep the fast path of override ClipRect + full push on render only,+ // which would be advantageous since most selectable are not selected.+ if (span_all_columns)+ {+ if (g.CurrentTable)+ TablePushBackgroundChannel();+ else if (window->DC.CurrentColumns)+ PushColumnsBackground();+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasClipRect;+ g.LastItemData.ClipRect = window->ClipRect;+ }++ // We use NoHoldingActiveID on menus so user can click and _hold_ on a menu then drag to browse child entries+ ImGuiButtonFlags button_flags = 0;+ if (flags & ImGuiSelectableFlags_NoHoldingActiveID) { button_flags |= ImGuiButtonFlags_NoHoldingActiveId; }+ if (flags & ImGuiSelectableFlags_NoSetKeyOwner) { button_flags |= ImGuiButtonFlags_NoSetKeyOwner; }+ if (flags & ImGuiSelectableFlags_SelectOnClick) { button_flags |= ImGuiButtonFlags_PressedOnClick; }+ if (flags & ImGuiSelectableFlags_SelectOnRelease) { button_flags |= ImGuiButtonFlags_PressedOnRelease; }+ if (flags & ImGuiSelectableFlags_AllowDoubleClick) { button_flags |= ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnDoubleClick; }+ if ((flags & ImGuiSelectableFlags_AllowOverlap) || (g.LastItemData.ItemFlags & ImGuiItemFlags_AllowOverlap)) { button_flags |= ImGuiButtonFlags_AllowOverlap; }++ // Multi-selection support (header)+ const bool was_selected = selected;+ if (is_multi_select)+ {+ // Handle multi-select + alter button flags for it+ MultiSelectItemHeader(id, &selected, &button_flags);+ }++ bool hovered, held;+ bool pressed = ButtonBehavior(bb, id, &hovered, &held, button_flags);+ bool auto_selected = false;++ // Multi-selection support (footer)+ if (is_multi_select)+ {+ MultiSelectItemFooter(id, &selected, &pressed);+ }+ else+ {+ // Auto-select when moved into+ // - This will be more fully fleshed in the range-select branch+ // - This is not exposed as it won't nicely work with some user side handling of shift/control+ // - We cannot do 'if (g.NavJustMovedToId != id) { selected = false; pressed = was_selected; }' for two reasons+ // - (1) it would require focus scope to be set, need exposing PushFocusScope() or equivalent (e.g. BeginSelection() calling PushFocusScope())+ // - (2) usage will fail with clipped items+ // The multi-select API aim to fix those issues, e.g. may be replaced with a BeginSelection() API.+ if ((flags & ImGuiSelectableFlags_SelectOnNav) && g.NavJustMovedToId != 0 && g.NavJustMovedToFocusScopeId == g.CurrentFocusScopeId && !g.NavJustMovedToIsInit)+ if (g.NavJustMovedToId == id && (g.NavJustMovedToKeyMods & ImGuiMod_Ctrl) == 0)+ selected = pressed = auto_selected = true;+ }++ // Update NavId when clicking or when Hovering (this doesn't happen on most widgets), so navigation can be resumed with keyboard/gamepad+ if (pressed || (hovered && (flags & ImGuiSelectableFlags_SetNavIdOnHover)))+ {+ if (!g.NavHighlightItemUnderNav && g.NavWindow == window && g.NavLayer == window->DC.NavLayerCurrent)+ {+ SetNavID(id, window->DC.NavLayerCurrent, g.CurrentFocusScopeId, WindowRectAbsToRel(window, bb)); // (bb == NavRect)+ if (g.IO.ConfigNavCursorVisibleAuto)+ g.NavCursorVisible = false;+ }+ }+ if (pressed)+ MarkItemEdited(id);++ if (selected != was_selected)+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_ToggledSelection;+ if (g.ActiveId == id && g.ActiveIdIsJustActivated)+ {+ g.ActiveIdWasSelected = was_selected;+ g.ActiveIdWasSoleSelected = was_selected && (!is_multi_select || g.CurrentMultiSelect->IsSoleOrUnknownSelectionSize);+ }++ // Render+ if (is_visible)+ {+ const bool highlighted = hovered || (flags & ImGuiSelectableFlags_Highlight);+ if (BuiOn()) // BUI: Blender rows: menu items in popups (menu_draw), pulldowns in menu bars, list items elsewhere+ {+ int kind = BK_WIDGET_LIST_ITEM;+ if (window->DC.LayoutType == ImGuiLayoutType_Horizontal && window->DC.NavLayerCurrent == ImGuiNavLayer_Menu)+ kind = BK_WIDGET_PULLDOWN;+ else if (window->Flags & ImGuiWindowFlags_Popup)+ kind = BK_WIDGET_MENU_ITEM;+ int st = (highlighted ? BK_WS_HOVER : 0) | (selected ? BK_WS_SELECTED : 0);+ if (kind == BK_WIDGET_MENU_ITEM && highlighted)+ st &= ~BK_WS_SELECTED; // the hover highlight wins, as in Blender's menus+ if (highlighted || selected)+ BuiEmit(BuiWidget(kind, bb, st));+ }+ else if (highlighted || selected) // BUI+ {+ // Between 1.91.0 and 1.91.4 we made selected Selectable use an arbitrary lerp between _Header and _HeaderHovered. Removed that now. (#8106)+ ImU32 col = GetColorU32((held && highlighted) ? ImGuiCol_HeaderActive : highlighted ? ImGuiCol_HeaderHovered : ImGuiCol_Header);+ RenderFrame(bb.Min, bb.Max, col, false, style.SelectableRounding);+ }+ if (g.NavId == id)+ {+ ImGuiNavRenderCursorFlags nav_render_cursor_flags = ImGuiNavRenderCursorFlags_Compact;+ if (is_multi_select)+ nav_render_cursor_flags |= ImGuiNavRenderCursorFlags_AlwaysDraw; // Always show the nav rectangle+ RenderNavCursor(bb, id, nav_render_cursor_flags, style.SelectableRounding);+ }+ }++ if (span_all_columns)+ {+ if (g.CurrentTable)+ TablePopBackgroundChannel();+ else if (window->DC.CurrentColumns)+ PopColumnsBackground();+ }++ // Text stays at the submission position. Alignment/clipping extents ignore SpanAllColumns.+ if (is_visible)+ RenderTextClipped(pos, ImVec2(ImMin(pos.x + size.x, window->WorkRect.Max.x), pos.y + size.y), label, label_end, &label_size, style.SelectableTextAlign, &bb);++#ifdef IMGUI_DEBUG_BOXSELECT+ if (g.BoxSelectState.UnclipMode) { GetForegroundDrawList()->AddText(pos, IM_COL32(255,255,0,200), label, label_end); }+#endif++ // Automatically close popups+ if (pressed && !auto_selected && (window->Flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiSelectableFlags_NoAutoClosePopups) && (g.LastItemData.ItemFlags & ImGuiItemFlags_AutoClosePopups))+ CloseCurrentPopup();++ if (disabled_item && !disabled_global)+ EndDisabled();++ // Selectable() always returns a pressed state!+ // Users of BeginMultiSelect()/EndMultiSelect() scope: you may call ImGui::IsItemToggledSelection() to retrieve+ // selection toggle, only useful if you need that state updated (e.g. for rendering purpose) before reaching EndMultiSelect().+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return pressed; //-V1020+}++bool ImGui::Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags, const ImVec2& size_arg)+{+ if (Selectable(label, *p_selected, flags, size_arg))+ {+ *p_selected = !*p_selected;+ return true;+ }+ return false;+}+++//-------------------------------------------------------------------------+// [SECTION] Widgets: Typing-Select support+//-------------------------------------------------------------------------++// [Experimental] Currently not exposed in public API.+// Consume character inputs and return search request, if any.+// This would typically only be called on the focused window or location you want to grab inputs for, e.g.+// if (ImGui::IsWindowFocused(...))+// if (ImGuiTypingSelectRequest* req = ImGui::GetTypingSelectRequest())+// focus_idx = ImGui::TypingSelectFindMatch(req, my_items.size(), [](void*, int n) { return my_items[n]->Name; }, &my_items, -1);+// However the code is written in a way where calling it from multiple locations is safe (e.g. to obtain buffer).+ImGuiTypingSelectRequest* ImGui::GetTypingSelectRequest(ImGuiTypingSelectFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiTypingSelectState* data = &g.TypingSelectState;+ ImGuiTypingSelectRequest* out_request = &data->Request;++ // Clear buffer+ const float TYPING_SELECT_RESET_TIMER = 1.80f; // FIXME: Potentially move to IO config.+ const int TYPING_SELECT_SINGLE_CHAR_COUNT_FOR_LOCK = 4; // Lock single char matching when repeating same char 4 times+ if (data->SearchBuffer[0] != 0)+ {+ bool clear_buffer = false;+ clear_buffer |= (g.NavFocusScopeId != data->FocusScope);+ clear_buffer |= (data->LastRequestTime + TYPING_SELECT_RESET_TIMER < g.Time);+ clear_buffer |= g.NavAnyRequest;+ clear_buffer |= g.ActiveId != 0 && g.NavActivateId == 0; // Allow temporary SPACE activation to not interfere+ clear_buffer |= IsKeyPressed(ImGuiKey_Escape) || IsKeyPressed(ImGuiKey_Enter);+ clear_buffer |= IsKeyPressed(ImGuiKey_Backspace) && (flags & ImGuiTypingSelectFlags_AllowBackspace) == 0;+ //if (clear_buffer) { IMGUI_DEBUG_LOG("GetTypingSelectRequest(): Clear SearchBuffer.\n"); }+ if (clear_buffer)+ data->Clear();+ }++ // Append to buffer+ const int buffer_max_len = IM_COUNTOF(data->SearchBuffer) - 1;+ int buffer_len = (int)ImStrlen(data->SearchBuffer);+ bool select_request = false;+ for (ImWchar w : g.IO.InputQueueCharacters)+ {+ const int w_len = ImTextCountUtf8BytesFromStr(&w, &w + 1);+ if (w < 32 || (buffer_len == 0 && ImCharIsBlankW(w)) || (buffer_len + w_len > buffer_max_len)) // Ignore leading blanks+ continue;+ char w_buf[5];+ ImTextCharToUtf8(w_buf, (unsigned int)w);+ if (data->SingleCharModeLock && w_len == out_request->SingleCharSize && memcmp(w_buf, data->SearchBuffer, w_len) == 0)+ {+ select_request = true; // Same character: don't need to append to buffer.+ continue;+ }+ if (data->SingleCharModeLock)+ {+ data->Clear(); // Different character: clear+ buffer_len = 0;+ }+ memcpy(data->SearchBuffer + buffer_len, w_buf, w_len + 1); // Append+ buffer_len += w_len;+ select_request = true;+ }+ g.IO.InputQueueCharacters.resize(0);++ // Handle backspace+ if ((flags & ImGuiTypingSelectFlags_AllowBackspace) && IsKeyPressed(ImGuiKey_Backspace, ImGuiInputFlags_Repeat))+ {+ char* p = (char*)(void*)ImTextFindPreviousUtf8Codepoint(data->SearchBuffer, data->SearchBuffer + buffer_len);+ *p = 0;+ buffer_len = (int)(p - data->SearchBuffer);+ }++ // Return request if any+ if (buffer_len == 0)+ return NULL;+ if (select_request)+ {+ data->FocusScope = g.NavFocusScopeId;+ data->LastRequestFrame = g.FrameCount;+ data->LastRequestTime = (float)g.Time;+ }+ out_request->Flags = flags;+ out_request->SearchBufferLen = buffer_len;+ out_request->SearchBuffer = data->SearchBuffer;+ out_request->SelectRequest = (data->LastRequestFrame == g.FrameCount);+ out_request->SingleCharMode = false;+ out_request->SingleCharSize = 0;++ // Calculate if buffer contains the same character repeated.+ // - This can be used to implement a special search mode on first character.+ // - Performed on UTF-8 codepoint for correctness.+ // - SingleCharMode is always set for first input character, because it usually leads to a "next".+ if (flags & ImGuiTypingSelectFlags_AllowSingleCharMode)+ {+ const char* buf_begin = out_request->SearchBuffer;+ const char* buf_end = out_request->SearchBuffer + out_request->SearchBufferLen;+ const int c0_len = ImTextCountUtf8BytesFromChar(buf_begin, buf_end);+ const char* p = buf_begin + c0_len;+ for (; p < buf_end; p += c0_len)+ if (memcmp(buf_begin, p, (size_t)c0_len) != 0)+ break;+ const int single_char_count = (p == buf_end) ? (out_request->SearchBufferLen / c0_len) : 0;+ out_request->SingleCharMode = (single_char_count > 0 || data->SingleCharModeLock);+ out_request->SingleCharSize = (ImS8)c0_len;+ data->SingleCharModeLock |= (single_char_count >= TYPING_SELECT_SINGLE_CHAR_COUNT_FOR_LOCK); // From now on we stop search matching to lock to single char mode.+ }++ return out_request;+}++static int ImStrimatchlen(const char* s1, const char* s1_end, const char* s2)+{+ int match_len = 0;+ while (s1 < s1_end && ImToUpper(*s1++) == ImToUpper(*s2++))+ match_len++;+ return match_len;+}++// Default handler for finding a result for typing-select. You may implement your own.+// You might want to display a tooltip to visualize the current request SearchBuffer+// When SingleCharMode is set:+// - it is better to NOT display a tooltip of other on-screen display indicator.+// - the index of the currently focused item is required.+// if your SetNextItemSelectionUserData() values are indices, you can obtain it from ImGuiMultiSelectIO::NavIdItem, otherwise from g.NavLastValidSelectionUserData.+int ImGui::TypingSelectFindMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx)+{+ if (req == NULL || req->SelectRequest == false) // Support NULL parameter so both calls can be done from same spot.+ return -1;+ int idx = -1;+ if (req->SingleCharMode && (req->Flags & ImGuiTypingSelectFlags_AllowSingleCharMode))+ idx = TypingSelectFindNextSingleCharMatch(req, items_count, get_item_name_func, user_data, nav_item_idx);+ else+ idx = TypingSelectFindBestLeadingMatch(req, items_count, get_item_name_func, user_data);+ if (idx != -1)+ SetNavCursorVisibleAfterMove();+ return idx;+}++// Special handling when a single character is repeated: perform search on a single letter and goes to next.+int ImGui::TypingSelectFindNextSingleCharMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx)+{+ // FIXME: Assume selection user data is index. Would be extremely practical.+ //if (nav_item_idx == -1)+ // nav_item_idx = (int)g.NavLastValidSelectionUserData;++ int first_match_idx = -1;+ bool return_next_match = false;+ for (int idx = 0; idx < items_count; idx++)+ {+ const char* item_name = get_item_name_func(user_data, idx);+ if (ImStrimatchlen(req->SearchBuffer, req->SearchBuffer + req->SingleCharSize, item_name) < req->SingleCharSize)+ continue;+ if (return_next_match) // Return next matching item after current item.+ return idx;+ if (first_match_idx == -1 && nav_item_idx == -1) // Return first match immediately if we don't have a nav_item_idx value.+ return idx;+ if (first_match_idx == -1) // Record first match for wrapping.+ first_match_idx = idx;+ if (nav_item_idx == idx) // Record that we encountering nav_item so we can return next match.+ return_next_match = true;+ }+ return first_match_idx; // First result+}++int ImGui::TypingSelectFindBestLeadingMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data)+{+ int longest_match_idx = -1;+ int longest_match_len = 0;+ for (int idx = 0; idx < items_count; idx++)+ {+ const char* item_name = get_item_name_func(user_data, idx);+ const int match_len = ImStrimatchlen(req->SearchBuffer, req->SearchBuffer + req->SearchBufferLen, item_name);+ if (match_len <= longest_match_len)+ continue;+ longest_match_idx = idx;+ longest_match_len = match_len;+ if (match_len == req->SearchBufferLen)+ break;+ }+ return longest_match_idx;+}++void ImGui::DebugNodeTypingSelectState(ImGuiTypingSelectState* data)+{+#ifndef IMGUI_DISABLE_DEBUG_TOOLS+ Text("SearchBuffer = \"%s\"", data->SearchBuffer);+ Text("SingleCharMode = %d, Size = %d, Lock = %d", data->Request.SingleCharMode, data->Request.SingleCharSize, data->SingleCharModeLock);+ Text("LastRequest = time: %.2f, frame: %d", data->LastRequestTime, data->LastRequestFrame);+#else+ IM_UNUSED(data);+#endif+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: Box-Select support+// This has been extracted away from Multi-Select logic in the hope that it could eventually be used elsewhere, but hasn't been yet.+//-------------------------------------------------------------------------+// Extra logic in MultiSelectItemFooter() and ImGuiListClipper::Step()+//-------------------------------------------------------------------------+// - BoxSelectPreStartDrag() [Internal]+// - BoxSelectActivateDrag() [Internal]+// - BoxSelectDeactivateDrag() [Internal]+// - BoxSelectScrollWithMouseDrag() [Internal]+// - BeginBoxSelect() [Internal]+// - EndBoxSelect() [Internal]+//-------------------------------------------------------------------------++// Call on the initial click.+static void BoxSelectPreStartDrag(ImGuiID id, ImGuiSelectionUserData clicked_item)+{+ ImGuiContext& g = *GImGui;+ ImGuiBoxSelectState* bs = &g.BoxSelectState;+ bs->ID = id;+ bs->IsStarting = true; // Consider starting box-select.+ bs->IsStartedFromVoid = (clicked_item == ImGuiSelectionUserData_Invalid);+ bs->IsStartedSetNavIdOnce = bs->IsStartedFromVoid;+ bs->KeyMods = g.IO.KeyMods;+ bs->StartPosRel = bs->EndPosRel = ImGui::WindowPosAbsToRel(g.CurrentWindow, g.IO.MousePos);+ bs->ScrollAccum = ImVec2(0.0f, 0.0f);+}++static void BoxSelectActivateDrag(ImGuiBoxSelectState* bs, ImGuiWindow* window)+{+ ImGuiContext& g = *GImGui;+ IMGUI_DEBUG_LOG_SELECTION("[selection] BeginBoxSelect() 0X%08X: Activate\n", bs->ID);+ bs->IsActive = true;+ bs->Window = window;+ bs->IsStarting = false;+ ImGui::SetActiveID(bs->ID, window);+ ImGui::SetActiveIdUsingAllKeyboardKeys();+ if (bs->IsStartedFromVoid && (bs->KeyMods & (ImGuiMod_Ctrl | ImGuiMod_Shift)) == 0)+ bs->RequestClear = true;+}++static void BoxSelectDeactivateDrag(ImGuiBoxSelectState* bs)+{+ ImGuiContext& g = *GImGui;+ bs->IsActive = bs->IsStarting = false;+ if (g.ActiveId == bs->ID)+ {+ IMGUI_DEBUG_LOG_SELECTION("[selection] BeginBoxSelect() 0X%08X: Deactivate\n", bs->ID);+ ImGui::ClearActiveID();+ }+ bs->ID = 0;+}++static void BoxSelectScrollWithMouseDrag(ImGuiBoxSelectState* bs, ImGuiWindow* window, const ImRect& inner_r)+{+ ImGuiContext& g = *GImGui;+ IM_ASSERT(bs->Window == window);+ for (int n = 0; n < 2; n++) // each axis+ {+ const float mouse_pos = g.IO.MousePos[n];+ const float dist = (mouse_pos > inner_r.Max[n]) ? mouse_pos - inner_r.Max[n] : (mouse_pos < inner_r.Min[n]) ? mouse_pos - inner_r.Min[n] : 0.0f;+ const float scroll_curr = window->Scroll[n];+ if (dist == 0.0f || (dist < 0.0f && scroll_curr < 0.0f) || (dist > 0.0f && scroll_curr >= window->ScrollMax[n]))+ continue;++ const float speed_multiplier = ImLinearRemapClamp(g.FontSize, g.FontSize * 5.0f, 1.0f, 4.0f, ImAbs(dist)); // x1 to x4 depending on distance+ const float scroll_step = g.FontSize * 35.0f * speed_multiplier * ImSign(dist) * g.IO.DeltaTime;+ bs->ScrollAccum[n] += scroll_step;++ // Accumulate into a stored value so we can handle high-framerate+ const float scroll_step_i = ImFloor(bs->ScrollAccum[n]);+ if (scroll_step_i == 0.0f)+ continue;+ if (n == 0)+ ImGui::SetScrollX(window, scroll_curr + scroll_step_i);+ else+ ImGui::SetScrollY(window, scroll_curr + scroll_step_i);+ bs->ScrollAccum[n] -= scroll_step_i;+ }+}++bool ImGui::BeginBoxSelect(const ImRect& scope_rect, ImGuiWindow* window, ImGuiID box_select_id, ImGuiMultiSelectFlags ms_flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiBoxSelectState* bs = &g.BoxSelectState;+ KeepAliveID(box_select_id);+ if (bs->ID != box_select_id)+ return false;++ // IsStarting is set by MultiSelectItemFooter() when considering a possible box-select. We validate it here and lock geometry.+ bs->UnclipMode = false;+ bs->RequestClear = false;+ if (bs->IsStarting && IsMouseDragPastThreshold(0))+ BoxSelectActivateDrag(bs, window);+ else if ((bs->IsStarting || bs->IsActive) && g.IO.MouseDown[0] == false)+ BoxSelectDeactivateDrag(bs);+ if (!bs->IsActive)+ return false;++ // Current frame absolute prev/current rectangles are used to toggle selection.+ // They are derived from positions relative to scrolling space, so "previous" rectangle is reprojected for current frame coordinates.+ ImVec2 start_pos_abs = WindowPosRelToAbs(window, bs->StartPosRel);+ ImVec2 prev_end_pos_abs = WindowPosRelToAbs(window, bs->EndPosRel); // Clamped already+ ImVec2 curr_end_pos_abs = g.IO.MousePos;+ if (ms_flags & ImGuiMultiSelectFlags_ScopeWindow) // Box-select scrolling only happens with ScopeWindow+ curr_end_pos_abs = ImClamp(curr_end_pos_abs, scope_rect.Min, scope_rect.Max);+ bs->BoxSelectRectPrev.Min = ImMin(start_pos_abs, prev_end_pos_abs);+ bs->BoxSelectRectPrev.Max = ImMax(start_pos_abs, prev_end_pos_abs);+ bs->BoxSelectRectCurr.Min = ImMin(start_pos_abs, curr_end_pos_abs);+ bs->BoxSelectRectCurr.Max = ImMax(start_pos_abs, curr_end_pos_abs);+ //IMGUI_DEBUG_LOG("StartPosRel (%.2f,%.2f) EndPosRel (%.2f,%.2f) -> (%.2f,%.2f)\n", bs->StartPosRel.x, bs->StartPosRel.y, bs->EndPosRel.x, bs->EndPosRel.y, WindowPosAbsToRel(window, g.IO.MousePos).x, WindowPosAbsToRel(window, g.IO.MousePos).y);++ // Box-select 2D mode detects change of the rectangle.+ // Storing unclip rects which will be tested by widgets supporting box-select. Always update rectangles when active (even if we don't use them).+ // To facilitate understanding this: enable IMGUI_DEBUG_BOXSELECT and visualize all geometry.+ if (ms_flags & (ImGuiMultiSelectFlags_BoxSelect1d | ImGuiMultiSelectFlags_BoxSelect2d))+ {+ // For both sides, compute the area differing between Prev and Curr rectangles.+ bs->UnclipRects[0] = bs->UnclipRects[1] = ImRect(+FLT_MAX, +FLT_MAX, -FLT_MAX, -FLT_MAX);+ for (int side = 0; side < 2; side++)+ {+ ImVec2 d_min = (side == 0) ? ImMin(bs->BoxSelectRectCurr.Min, bs->BoxSelectRectPrev.Min) : ImMin(bs->BoxSelectRectCurr.Max, bs->BoxSelectRectPrev.Max);+ ImVec2 d_max = (side == 0) ? ImMax(bs->BoxSelectRectCurr.Min, bs->BoxSelectRectPrev.Min) : ImMax(bs->BoxSelectRectCurr.Max, bs->BoxSelectRectPrev.Max);+ if (d_min.x != d_max.x)+ {+ bs->UnclipRects[0].AddX(d_min.x);+ bs->UnclipRects[0].AddX(d_max.x);+ }+ if (d_min.y != d_max.y)+ {+ bs->UnclipRects[1].AddY(d_min.y);+ bs->UnclipRects[1].AddY(d_max.y);+ }+ }++ ImRect box_select_intersection = bs->BoxSelectRectPrev;+ box_select_intersection.Add(bs->BoxSelectRectCurr);+ if (ms_flags & ImGuiMultiSelectFlags_BoxSelect2d)+ if (bs->BoxSelectRectPrev.Min.x != bs->BoxSelectRectCurr.Min.x || bs->BoxSelectRectPrev.Max.x != bs->BoxSelectRectCurr.Max.x)+ {+ bs->UnclipRects[0].AddY(box_select_intersection.Min.y);+ bs->UnclipRects[0].AddY(box_select_intersection.Max.y);+ }+ if (ms_flags & (ImGuiMultiSelectFlags_BoxSelect1d | ImGuiMultiSelectFlags_BoxSelect2d))+ if (bs->BoxSelectRectPrev.Min.y != bs->BoxSelectRectCurr.Min.y || bs->BoxSelectRectPrev.Max.y != bs->BoxSelectRectCurr.Max.y)+ {+ bs->UnclipRects[1].AddX(box_select_intersection.Min.x);+ bs->UnclipRects[1].AddX(box_select_intersection.Max.x);+ }++ // Merge both rectangles into one.+ // FIXME-OPT: When UnclipRect.Area() is much larger than the sum of UnclipRects[0]/[1] Areas, widgets should+ // ideally first use UnclipRect as a first coarse cull layer + the individual ones as a second validation.+ bs->UnclipRect = bs->UnclipRects[0];+ bs->UnclipRect.Add(bs->UnclipRects[1]);+ if (!bs->UnclipRect.IsInverted() && (!window->ClipRect.Contains(bs->UnclipRect.Min) || !window->ClipRect.Contains(bs->UnclipRect.Max))) // !! Don't use Contains(ImRect)+ bs->UnclipMode = true;+ if (bs->UnclipMode && g.CurrentTable != NULL)+ TableApplyExternalUnclipRect(g.CurrentTable, bs->UnclipRect); // No need submitting both+ }++#ifdef IMGUI_DEBUG_BOXSELECT+ //GetForegroundDrawList()->AddRect(scope_rect.Min, scope_rect.Max, IM_COL32(0, 255, 0, 200), 0.0f, 0, 4.0f);+ //GetForegroundDrawList()->AddRect(bs->BoxSelectRectPrev.Min, bs->BoxSelectRectPrev.Max, IM_COL32(255,0,0,200), 0.0f, 0, 3.0f);+ //GetForegroundDrawList()->AddRect(bs->BoxSelectRectCurr.Min, bs->BoxSelectRectCurr.Max, IM_COL32(0,255,0,200), 0.0f, 0, 1.0f);+ if (ms_flags & (ImGuiMultiSelectFlags_BoxSelect1d | ImGuiMultiSelectFlags_BoxSelect2d))+ {+ for (ImRect& unclip_r : bs->UnclipRects)+ if (!unclip_r.IsInverted())+ GetForegroundDrawList()->AddRect(unclip_r.Min, unclip_r.Max, bs->UnclipMode ? IM_COL32(255, 255, 0, 200) : IM_COL32(255, 0, 0, 200), 0.0f, 0, 4.0f);+ GetForegroundDrawList()->AddRect(bs->UnclipRect.Min, bs->UnclipRect.Max, bs->UnclipMode ? IM_COL32(255, 255, 0, 200) : IM_COL32(255, 0, 0, 200), 0.0f, 0, 2.0f);+ }+#endif+ return true;+}++void ImGui::EndBoxSelect(const ImRect& scope_rect, ImGuiMultiSelectFlags ms_flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ ImGuiBoxSelectState* bs = &g.BoxSelectState;+ IM_ASSERT(bs->IsActive);+ bs->UnclipMode = false;++ // Render selection rectangle+ bs->EndPosRel = WindowPosAbsToRel(window, ImClamp(g.IO.MousePos, scope_rect.Min, scope_rect.Max)); // Clamp stored position according to current scrolling view+ ImRect box_select_r = bs->BoxSelectRectCurr;+ box_select_r.ClipWith(scope_rect);+ ImGuiWindow* draw_window = FindFrontMostVisibleChildWindow(window);+ draw_window->DrawList->AddRectFilled(box_select_r.Min, box_select_r.Max, GetColorU32(ImGuiCol_SeparatorHovered, 0.30f)); // FIXME-MULTISELECT: Styling+ draw_window->DrawList->AddRect(box_select_r.Min, box_select_r.Max, GetColorU32(ImGuiCol_NavCursor)); // FIXME-MULTISELECT FIXME-DPI: Styling++ // Scroll+ const bool enable_scroll = (ms_flags & ImGuiMultiSelectFlags_ScopeWindow) && (ms_flags & ImGuiMultiSelectFlags_BoxSelectNoScroll) == 0;+ if (enable_scroll)+ {+ ImRect scroll_r = scope_rect;+ scroll_r.Expand(-g.FontSize);+ //GetForegroundDrawList()->AddRect(scroll_r.Min, scroll_r.Max, IM_COL32(0, 255, 0, 255));+ if (!scroll_r.Contains(g.IO.MousePos))+ BoxSelectScrollWithMouseDrag(bs, window, scroll_r);+ }+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: Multi-Select support+//-------------------------------------------------------------------------+// - DebugLogMultiSelectRequests() [Internal]+// - CalcScopeRect() [Internal]+// - BeginMultiSelect()+// - EndMultiSelect()+// - SetNextItemSelectionUserData()+// - MultiSelectItemHeader() [Internal]+// - MultiSelectItemFooter() [Internal]+// - DebugNodeMultiSelectState() [Internal]+//-------------------------------------------------------------------------++static void DebugLogMultiSelectRequests(const char* function, const ImGuiMultiSelectIO* io)+{+ ImGuiContext& g = *GImGui;+ IM_UNUSED(function);+ for (const ImGuiSelectionRequest& req : io->Requests)+ {+ if (req.Type == ImGuiSelectionRequestType_SetAll) IMGUI_DEBUG_LOG_SELECTION("[selection] %s: Request: SetAll %d (= %s)\n", function, req.Selected, req.Selected ? "SelectAll" : "Clear");+ if (req.Type == ImGuiSelectionRequestType_SetRange) IMGUI_DEBUG_LOG_SELECTION("[selection] %s: Request: SetRange %" IM_PRId64 "..%" IM_PRId64 " (0x%" IM_PRIX64 "..0x%" IM_PRIX64 ") = %d (dir %d)\n", function, req.RangeFirstItem, req.RangeLastItem, req.RangeFirstItem, req.RangeLastItem, req.Selected, req.RangeDirection);+ }+}++static ImRect CalcScopeRect(ImGuiMultiSelectTempData* ms, ImGuiWindow* window)+{+ if (ms->Flags & ImGuiMultiSelectFlags_ScopeRect)+ {+ // Warning: this depends on CursorMaxPos so it means to be called by EndMultiSelect() only+ // This probably doesn't work inside a table as there are ample ambiguities related to exact time of calling BeginMultiSelect()/EndMultiSelect().+ return ImRect(ms->ScopeRectMin, ImMax(window->DC.CursorMaxPos, ms->ScopeRectMin));+ }+ else+ {+ //// When a table, pull HostClipRect, which allows us to predict ClipRect before first row/layout is performed. (#7970)+ ImRect scope_rect = window->InnerClipRect;+ //if (g.CurrentTable != NULL)+ // scope_rect = g.CurrentTable->HostClipRect;++ // Add inner table decoration (#7821) // FIXME: Why not baking in InnerClipRect?+ scope_rect.Min = ImMin(scope_rect.Min + ImVec2(window->DecoInnerSizeX1, window->DecoInnerSizeY1), scope_rect.Max);+ return scope_rect;+ }+}++// Return ImGuiMultiSelectIO structure.+// Lifetime: don't hold on ImGuiMultiSelectIO* pointers over multiple frames or past any subsequent call to BeginMultiSelect() or EndMultiSelect().+// Passing 'selection_size' and 'items_count' parameters is currently optional.+// - 'selection_size' is useful to disable some shortcut routing: e.g. ImGuiMultiSelectFlags_ClearOnEscape won't claim Escape key when selection_size 0,+// allowing a first press to clear selection THEN the second press to leave child window and return to parent.+// - 'items_count' is stored in ImGuiMultiSelectIO which makes it a convenient way to pass the information to your ApplyRequest() handler (but you may pass it differently).+// - If they are costly for you to compute (e.g. external intrusive selection without maintaining size), you may avoid them and pass -1.+// - If you can easily tell if your selection is empty or not, you may pass 0/1, or you may enable ImGuiMultiSelectFlags_ClearOnEscape flag dynamically.+ImGuiMultiSelectIO* ImGui::BeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size, int items_count)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ if (++g.MultiSelectTempDataStacked > g.MultiSelectTempData.Size)+ g.MultiSelectTempData.resize(g.MultiSelectTempDataStacked, ImGuiMultiSelectTempData());+ ImGuiMultiSelectTempData* ms = &g.MultiSelectTempData[g.MultiSelectTempDataStacked - 1];+ IM_STATIC_ASSERT(offsetof(ImGuiMultiSelectTempData, IO) == 0); // Clear() relies on that.+ g.CurrentMultiSelect = ms;+ if ((flags & (ImGuiMultiSelectFlags_ScopeWindow | ImGuiMultiSelectFlags_ScopeRect)) == 0)+ flags |= ImGuiMultiSelectFlags_ScopeWindow;+ if (flags & ImGuiMultiSelectFlags_SingleSelect)+ flags &= ~(ImGuiMultiSelectFlags_BoxSelect2d | ImGuiMultiSelectFlags_BoxSelect1d);+ if (flags & ImGuiMultiSelectFlags_BoxSelect2d)+ flags &= ~ImGuiMultiSelectFlags_BoxSelect1d;++ // FIXME: Workaround to the fact we override CursorMaxPos, meaning size measurement are lost. (#8250)+ // They should perhaps be stacked properly?+ if (ImGuiTable* table = g.CurrentTable)+ {+ if (!table->IsLayoutLocked)+ TableUpdateLayout(table);+ else if (table->CurrentColumn != -1)+ TableEndCell(table); // This is currently safe to call multiple time. If that properly is lost we can extract the "save measurement" part of it.+ }++ // FIXME: BeginFocusScope()+ const ImGuiID id = window->IDStack.back();+ ms->Clear();+ ms->FocusScopeId = id;+ ms->Flags = flags;+ ms->BackupCursorMaxPos = window->DC.CursorMaxPos;+ ms->ScopeRectMin = window->DC.CursorPos;+ if (flags & ImGuiMultiSelectFlags_ScopeRect)+ window->DC.CursorMaxPos = ms->ScopeRectMin; // CalcScopeRect() for ImGuiMultiSelectFlags_ScopeRect will measure in EndMultiSelect().+ PushFocusScope(ms->FocusScopeId);+ ms->IsFocused = IsInNavFocusRoute(g.CurrentFocusScopeId);+ if (flags & ImGuiMultiSelectFlags_ScopeWindow) // Mark parent child window as navigable into, with highlight. Assume user will always submit interactive items.+ window->DC.NavLayersActiveMask |= 1 << ImGuiNavLayer_Main;++ // Use copy of keyboard mods at the time of the request, otherwise we would requires mods to be held for an extra frame.+ ms->KeyMods = g.NavJustMovedToId ? (g.NavJustMovedToIsTabbing ? 0 : g.NavJustMovedToKeyMods) : g.IO.KeyMods;+ if (flags & ImGuiMultiSelectFlags_NoRangeSelect)+ ms->KeyMods &= ~ImGuiMod_Shift;++ // Bind storage+ ImGuiMultiSelectState* storage = g.MultiSelectStorage.GetOrAddByKey(id);+ storage->ID = id;+ storage->LastFrameActive = g.FrameCount;+ storage->LastSelectionSize = selection_size;+ storage->Window = window;+ ms->Storage = storage;++ // Output to user+ ms->IO.Requests.resize(0);+ ms->IO.RangeSrcItem = storage->RangeSrcItem;+ ms->IO.NavIdItem = storage->NavIdItem;+ ms->IO.NavIdSelected = (storage->NavIdSelected == 1) ? true : false;+ ms->IO.ItemsCount = items_count;++ // Clear when using Navigation to move within the scope+ // (we compare FocusScopeId so it possible to use multiple selections inside a same window)+ bool request_clear = false;+ bool request_select_all = false;+ if (g.NavJustMovedToId != 0 && g.NavJustMovedToFocusScopeId == ms->FocusScopeId && g.NavJustMovedToHasSelectionData)+ {+ if (ms->KeyMods & ImGuiMod_Shift)+ ms->IsKeyboardSetRange = true;+ if (ms->IsKeyboardSetRange)+ IM_ASSERT(storage->RangeSrcItem != ImGuiSelectionUserData_Invalid); // Not ready -> could clear?+ if ((ms->KeyMods & (ImGuiMod_Ctrl | ImGuiMod_Shift)) == 0 && (flags & (ImGuiMultiSelectFlags_NoAutoClear | ImGuiMultiSelectFlags_NoAutoSelect)) == 0)+ request_clear = true;+ }+ else if (g.NavJustMovedFromFocusScopeId == ms->FocusScopeId)+ {+ // Also clear on leaving scope (may be optional?)+ if ((ms->KeyMods & (ImGuiMod_Ctrl | ImGuiMod_Shift)) == 0 && (flags & (ImGuiMultiSelectFlags_NoAutoClear | ImGuiMultiSelectFlags_NoAutoSelect)) == 0)+ request_clear = true;+ }++ // Box-select handling: update active state.+ ImGuiBoxSelectState* bs = &g.BoxSelectState;+ if (flags & (ImGuiMultiSelectFlags_BoxSelect1d | ImGuiMultiSelectFlags_BoxSelect2d))+ {+ ms->BoxSelectId = GetID("##BoxSelect");+ if (BeginBoxSelect(CalcScopeRect(ms, window), window, ms->BoxSelectId, flags))+ request_clear |= bs->RequestClear;+ }++ if (ms->IsFocused)+ {+ // Shortcut: Clear selection (Escape)+ // - Only claim shortcut if selection is not empty, allowing further presses on Escape to e.g. leave current child window.+ // - Box select also handle Escape and needs to pass an id to bypass ActiveIdUsingAllKeyboardKeys lock.+ if (flags & ImGuiMultiSelectFlags_ClearOnEscape)+ {+ if (selection_size != 0 || bs->IsActive)+ if (Shortcut(ImGuiKey_Escape, ImGuiInputFlags_None, bs->IsActive ? bs->ID : 0))+ {+ request_clear = true;+ if (bs->IsActive)+ BoxSelectDeactivateDrag(bs);+ }+ }++ // Shortcut: Select all (Ctrl+A)+ if (!(flags & ImGuiMultiSelectFlags_SingleSelect) && !(flags & ImGuiMultiSelectFlags_NoSelectAll))+ if (Shortcut(ImGuiMod_Ctrl | ImGuiKey_A))+ request_select_all = true;+ }++ if (request_clear || request_select_all)+ {+ MultiSelectAddSetAll(ms, request_select_all);+ if (!request_select_all)+ storage->LastSelectionSize = 0;+ }+ ms->LoopRequestSetAll = request_select_all ? 1 : request_clear ? 0 : -1;+ ms->IsSoleOrUnknownSelectionSize = (storage->LastSelectionSize == 1) || (storage->LastSelectionSize == -1);+ //ms->PrevSubmittedItem = ImGuiSelectionUserData_Invalid;++ if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection)+ DebugLogMultiSelectRequests("BeginMultiSelect", &ms->IO);++ return &ms->IO;+}++// Return updated ImGuiMultiSelectIO structure.+// Lifetime: don't hold on ImGuiMultiSelectIO* pointers over multiple frames or past any subsequent call to BeginMultiSelect() or EndMultiSelect().+ImGuiMultiSelectIO* ImGui::EndMultiSelect()+{+ ImGuiContext& g = *GImGui;+ ImGuiMultiSelectTempData* ms = g.CurrentMultiSelect;+ ImGuiMultiSelectState* storage = ms->Storage;+ ImGuiWindow* window = g.CurrentWindow;+ IM_ASSERT_USER_ERROR(ms->FocusScopeId == g.CurrentFocusScopeId, "EndMultiSelect() FocusScope mismatch!");+ IM_ASSERT(g.CurrentMultiSelect != NULL && storage->Window == g.CurrentWindow);+ IM_ASSERT(g.MultiSelectTempDataStacked > 0 && &g.MultiSelectTempData[g.MultiSelectTempDataStacked - 1] == g.CurrentMultiSelect);++ ImRect scope_rect = CalcScopeRect(ms, window);+ if (ms->IsFocused)+ {+ // We currently don't allow user code to modify RangeSrcItem by writing to BeginIO's version, but that would be an easy change here.+ if (ms->IO.RangeSrcReset || (ms->RangeSrcPassedBy == false && ms->IO.RangeSrcItem != ImGuiSelectionUserData_Invalid)) // Can't read storage->RangeSrcItem here -> we want the state at beginning of the scope (see tests for easy failure)+ {+ IMGUI_DEBUG_LOG_SELECTION("[selection] EndMultiSelect: Reset RangeSrcItem.\n"); // Will set be to NavId.+ storage->RangeSrcItem = ImGuiSelectionUserData_Invalid;+ }+ if (ms->NavIdPassedBy == false && storage->NavIdItem != ImGuiSelectionUserData_Invalid)+ {+ IMGUI_DEBUG_LOG_SELECTION("[selection] EndMultiSelect: Reset NavIdItem.\n");+ storage->NavIdItem = ImGuiSelectionUserData_Invalid;+ storage->NavIdSelected = -1;+ }++ if ((ms->Flags & (ImGuiMultiSelectFlags_BoxSelect1d | ImGuiMultiSelectFlags_BoxSelect2d)) && GetBoxSelectState(ms->BoxSelectId))+ EndBoxSelect(scope_rect, ms->Flags);+ }++ if (ms->IsEndIO == false)+ ms->IO.Requests.resize(0);++ // Clear selection when clicking void?+ // We specifically test for IsMouseDragPastThreshold(0) == false to allow box-selection!+ // The InnerRect test is necessary for non-child/decorated windows.+ bool scope_hovered = window->InnerRect.Contains(g.IO.MousePos) && IsWindowHovered(ImGuiHoveredFlags_ChildWindows);+ if (scope_hovered && (ms->Flags & ImGuiMultiSelectFlags_ScopeRect))+ scope_hovered &= scope_rect.Contains(g.IO.MousePos);+ if (scope_hovered && g.HoveredId == 0 && g.ActiveId == 0)+ {+ if (ms->Flags & (ImGuiMultiSelectFlags_BoxSelect1d | ImGuiMultiSelectFlags_BoxSelect2d))+ {+ if (!g.BoxSelectState.IsActive && !g.BoxSelectState.IsStarting && g.IO.MouseClickedCount[0] == 1)+ {+ BoxSelectPreStartDrag(ms->BoxSelectId, ImGuiSelectionUserData_Invalid);+ FocusWindow(window, ImGuiFocusRequestFlags_UnlessBelowModal);+ SetHoveredID(ms->BoxSelectId);+ if (ms->Flags & ImGuiMultiSelectFlags_ScopeRect)+ SetNavID(0, ImGuiNavLayer_Main, ms->FocusScopeId, ImRect(g.IO.MousePos, g.IO.MousePos)); // Automatically switch FocusScope for initial click from void to box-select.+ }+ }++ if (ms->Flags & ImGuiMultiSelectFlags_ClearOnClickVoid)+ if (IsMouseReleased(0) && IsMouseDragPastThreshold(0) == false && g.IO.KeyMods == ImGuiMod_None)+ MultiSelectAddSetAll(ms, false);+ }++ // Courtesy nav wrapping helper flag+ if (ms->Flags & ImGuiMultiSelectFlags_NavWrapX)+ {+ IM_ASSERT(ms->Flags & ImGuiMultiSelectFlags_ScopeWindow); // Only supported at window scope+ NavMoveRequestTryWrapping(GetCurrentWindow(), ImGuiNavMoveFlags_WrapX);+ }++ // Unwind+ if (ImGuiTable* table = g.CurrentTable)+ if (table->IsInsideRow)+ TableEndRow(table);+ window->DC.CursorMaxPos = ImMax(ms->BackupCursorMaxPos, window->DC.CursorMaxPos);+ PopFocusScope();++ if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection)+ DebugLogMultiSelectRequests("EndMultiSelect", &ms->IO);++ ms->FocusScopeId = 0;+ ms->Flags = ImGuiMultiSelectFlags_None;+ g.CurrentMultiSelect = (--g.MultiSelectTempDataStacked > 0) ? &g.MultiSelectTempData[g.MultiSelectTempDataStacked - 1] : NULL;++ return &ms->IO;+}++void ImGui::SetNextItemSelectionUserData(ImGuiSelectionUserData selection_user_data)+{+ // Note that flags will be cleared by ItemAdd(), so it's only useful for Navigation code!+ // This designed so widgets can also cheaply set this before calling ItemAdd(), so we are not tied to MultiSelect api.+ ImGuiContext& g = *GImGui;+ g.NextItemData.SelectionUserData = selection_user_data;+ g.NextItemData.FocusScopeId = g.CurrentFocusScopeId;++ if (ImGuiMultiSelectTempData* ms = g.CurrentMultiSelect)+ {+ // Auto updating RangeSrcPassedBy for cases were clipper is not used (done before ItemAdd() clipping)+ g.NextItemData.ItemFlagsSet |= ImGuiItemFlags_HasSelectionUserData | ImGuiItemFlags_IsMultiSelect;+ if (ms->IO.RangeSrcItem == selection_user_data)+ ms->RangeSrcPassedBy = true;+ //ms->PrevSubmittedItem = ms->CurrSubmittedItem; // Can't rely on previous g.NextItemData.SelectionUserData because NextItemData is not restored on nested multi-select.+ //ms->CurrSubmittedItem = selection_user_data;+ }+ else+ {+ g.NextItemData.ItemFlagsSet |= ImGuiItemFlags_HasSelectionUserData;+ }+}++// In charge of:+// - Applying SetAll for submitted items.+// - Applying SetRange for submitted items and record end points.+// - Altering button behavior flags to facilitate use with drag and drop.+void ImGui::MultiSelectItemHeader(ImGuiID id, bool* p_selected, ImGuiButtonFlags* p_button_flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiMultiSelectTempData* ms = g.CurrentMultiSelect;++ bool selected = *p_selected;+ if (ms->IsFocused)+ {+ ImGuiMultiSelectState* storage = ms->Storage;+ ImGuiSelectionUserData item_data = g.NextItemData.SelectionUserData;+ IM_ASSERT(g.NextItemData.FocusScopeId == g.CurrentFocusScopeId && "Forgot to call SetNextItemSelectionUserData() prior to item, required in BeginMultiSelect()/EndMultiSelect() scope");++ // Apply SetAll (Clear/SelectAll) requests requested by BeginMultiSelect().+ // This is only useful if the user hasn't processed them already, and this only works if the user isn't using the clipper.+ // If you are using a clipper you need to process the SetAll request after calling BeginMultiSelect()+ if (ms->LoopRequestSetAll != -1)+ selected = (ms->LoopRequestSetAll == 1);++ // When using Shift+Nav: because it can incur scrolling we cannot afford a frame of lag with the selection highlight (otherwise scrolling would happen before selection)+ // For this to work, we need someone to set 'RangeSrcPassedBy = true' at some point (either clipper either SetNextItemSelectionUserData() function)+ if (ms->IsKeyboardSetRange)+ {+ IM_ASSERT(id != 0 && (ms->KeyMods & ImGuiMod_Shift) != 0);+ const bool is_range_dst = (ms->RangeDstPassedBy == false) && g.NavJustMovedToId == id; // Assume that g.NavJustMovedToId is not clipped.+ if (is_range_dst)+ ms->RangeDstPassedBy = true;+ if (is_range_dst && storage->RangeSrcItem == ImGuiSelectionUserData_Invalid) // If we don't have RangeSrc, assign RangeSrc = RangeDst+ {+ storage->RangeSrcItem = item_data;+ storage->RangeSelected = selected ? 1 : 0;+ }+ const bool is_range_src = storage->RangeSrcItem == item_data;+ if (is_range_src || is_range_dst || ms->RangeSrcPassedBy != ms->RangeDstPassedBy)+ {+ // Apply range-select value to visible items+ IM_ASSERT(storage->RangeSrcItem != ImGuiSelectionUserData_Invalid && storage->RangeSelected != -1);+ selected = (storage->RangeSelected != 0);+ }+ else if ((ms->KeyMods & ImGuiMod_Ctrl) == 0 && (ms->Flags & ImGuiMultiSelectFlags_NoAutoClear) == 0)+ {+ // Clear other items+ selected = false;+ }+ }+ *p_selected = selected;+ }++ // Alter button behavior flags+ // To handle drag and drop of multiple items we need to avoid clearing selection on click.+ // Enabling this test makes actions using Ctrl+Shift delay their effect on MouseUp which is annoying, but it allows drag and drop of multiple items.+ if (p_button_flags != NULL)+ {+ ImGuiButtonFlags button_flags = *p_button_flags;+ button_flags |= ImGuiButtonFlags_NoHoveredOnFocus;+ button_flags &= ~(ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease);+ if (ms->Flags & ImGuiMultiSelectFlags_SelectOnClickAlways)+ button_flags |= ImGuiButtonFlags_PressedOnClick;+ else if (ms->Flags & ImGuiMultiSelectFlags_SelectOnClickRelease)+ button_flags |= ImGuiButtonFlags_PressedOnClickRelease;+ else // ImGuiMultiSelectFlags_SelectOnAuto+ button_flags |= (!selected || (g.ActiveId == id && g.ActiveIdHasBeenPressedBefore)) ? ImGuiButtonFlags_PressedOnClick : ImGuiButtonFlags_PressedOnClickRelease;+ *p_button_flags = button_flags;+ }+}++// In charge of:+// - Auto-select on navigation.+// - Box-select toggle handling.+// - Right-click handling.+// - Altering selection based on Ctrl/Shift modifiers, both for keyboard and mouse.+// - Record current selection state for RangeSrc+// This is all rather complex, best to run and refer to "widgets_multiselect_xxx" tests in imgui_test_suite.+void ImGui::MultiSelectItemFooter(ImGuiID id, bool* p_selected, bool* p_pressed, ImGuiMultiSelectFlags extra_flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ bool selected = *p_selected;+ bool pressed = *p_pressed;+ ImGuiMultiSelectTempData* ms = g.CurrentMultiSelect;+ ImGuiMultiSelectState* storage = ms->Storage;+ if (pressed)+ ms->IsFocused = true;++ bool hovered = false;+ if (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HoveredRect)+ hovered = IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup);+ if (!ms->IsFocused && !hovered)+ return;++ ImGuiSelectionUserData item_data = g.NextItemData.SelectionUserData;++ ImGuiMultiSelectFlags flags = ms->Flags | extra_flags;+ const bool is_singleselect = (flags & ImGuiMultiSelectFlags_SingleSelect) != 0;+ bool is_ctrl = (ms->KeyMods & ImGuiMod_Ctrl) != 0;+ bool is_shift = (ms->KeyMods & ImGuiMod_Shift) != 0;++ bool apply_to_range_src = false;++ if (g.NavId == id && storage->RangeSrcItem == ImGuiSelectionUserData_Invalid)+ apply_to_range_src = true;+ if (ms->IsEndIO == false)+ {+ ms->IO.Requests.resize(0);+ ms->IsEndIO = true;+ }++ // Auto-select as you navigate a list+ if (g.NavJustMovedToId == id)+ {+ if ((flags & ImGuiMultiSelectFlags_NoAutoSelect) == 0)+ {+ if (is_ctrl && is_shift)+ pressed = true;+ else if (!is_ctrl)+ selected = pressed = true;+ }+ else+ {+ // With NoAutoSelect, using Shift+keyboard performs a write/copy+ if (is_shift)+ pressed = true;+ else if (!is_ctrl)+ apply_to_range_src = true; // Since if (pressed) {} main block is not running we update this+ }+ }++ if (apply_to_range_src)+ {+ storage->RangeSrcItem = item_data;+ storage->RangeSelected = selected; // Will be updated at the end of this function anyway.+ }++ // Box-select toggle handling+ if (ms->BoxSelectId != 0)+ if (ImGuiBoxSelectState* bs = GetBoxSelectState(ms->BoxSelectId))+ {+ ImRect item_rect = g.LastItemData.Rect;+ if (!window->DC.NavIsScrollPushableX) // FIXME: Rename to be more generic.+ if (ImGuiTable* table = g.CurrentTable)+ if (table->CurrentColumn != -1)+ {+ // FIXME: We cannot solely use current ClipRect as it includes HostClipRect.+ // However we account for ClipRect being larger than current column (e.g. when using SpanAllColumns)+ // A more generic version would be nice, but window->WorkRect.Min/Max exclude CellPadding. (#7994, #9383)+ ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];+ float clip_min_x = (g.LastItemData.ItemFlags & ImGuiItemStatusFlags_HasClipRect) ? g.LastItemData.ClipRect.Min.x : window->ClipRect.Min.x;+ float clip_max_x = (g.LastItemData.ItemFlags & ImGuiItemStatusFlags_HasClipRect) ? g.LastItemData.ClipRect.Max.x : window->ClipRect.Max.x;+ if (clip_min_x != clip_max_x) // When zero sized we expect that bounds have been clamped and thus are unreliable+ {+ item_rect.Min.x = ImMax(item_rect.Min.x, ImMin(column->MinX, clip_min_x));+ item_rect.Max.x = ImMin(item_rect.Max.x, ImMax(column->MaxX, clip_max_x));+ }+ else+ {+ item_rect.Min.x = ImMax(item_rect.Min.x, column->MinX);+ item_rect.Max.x = ImMin(item_rect.Max.x, column->MaxX);+ }+ //GetForegroundDrawList()->AddRect(item_rect.Min, item_rect.Max, IM_COL32(255, 0, 255, 255));+ }+ const bool rect_overlap_curr = bs->BoxSelectRectCurr.Overlaps(item_rect);+ const bool rect_overlap_prev = bs->BoxSelectRectPrev.Overlaps(item_rect);+ if ((rect_overlap_curr && !rect_overlap_prev && !selected) || (rect_overlap_prev && !rect_overlap_curr))+ {+ if (storage->LastSelectionSize <= 0 && bs->IsStartedSetNavIdOnce)+ {+ pressed = true; // First item act as a pressed: code below will emit selection request and set NavId (whatever we emit here will be overridden anyway)+ bs->IsStartedSetNavIdOnce = false;+ }+ else+ {+ selected = !selected;+ MultiSelectAddSetRange(ms, selected, +1, item_data, item_data);+#ifdef IMGUI_DEBUG_BOXSELECT+ GetForegroundDrawList()->AddRectFilled(g.LastItemData.Rect.Min, g.LastItemData.Rect.Max, selected ? IM_COL32(0, 255, 0, 200) : IM_COL32(255, 0, 0, 200));+#endif+ }+ storage->LastSelectionSize = ImMax(storage->LastSelectionSize + 1, 1);+ }+ }++ // Right-click handling.+ // FIXME-MULTISELECT: Maybe should be moved to Selectable()? Also see #5816, #8200, #9015+ if (hovered && IsMouseClicked(1) && (flags & (ImGuiMultiSelectFlags_NoAutoSelect | ImGuiMultiSelectFlags_NoSelectOnRightClick)) == 0)+ {+ if (g.ActiveId != 0 && g.ActiveId != id)+ ClearActiveID();+ SetFocusID(id, window);+ if (!pressed && !selected)+ {+ pressed = true;+ is_ctrl = is_shift = false;+ }+ }++ // Unlike Space, Enter doesn't alter selection (but can still return a press) unless current item is not selected.+ // The later, "unless current item is not select", may become optional? It seems like a better default if Enter doesn't necessarily open something+ // (unlike e.g. Windows explorer). For use case where Enter always open something, we might decide to make this optional?+ const bool enter_pressed = pressed && (g.NavActivateId == id) && (g.NavActivateFlags & ImGuiActivateFlags_PreferInput);++ // Alter selection+ if (pressed && (!enter_pressed || !selected))+ {+ // Box-select+ ImGuiInputSource input_source = (g.NavJustMovedToId == id || g.NavActivateId == id) ? g.NavInputSource : ImGuiInputSource_Mouse;+ if (flags & (ImGuiMultiSelectFlags_BoxSelect1d | ImGuiMultiSelectFlags_BoxSelect2d))+ if (!g.BoxSelectState.IsActive && !g.BoxSelectState.IsStarting && input_source == ImGuiInputSource_Mouse && g.IO.MouseClickedCount[0] == 1)+ BoxSelectPreStartDrag(ms->BoxSelectId, item_data);++ //----------------------------------------------------------------------------------------+ // ACTION | Begin | Pressed/Activated | End+ //----------------------------------------------------------------------------------------+ // Keys Navigated: | Clear | Src=item, Sel=1 SetRange 1+ // Keys Navigated: Ctrl | n/a | n/a+ // Keys Navigated: Shift | n/a | Dst=item, Sel=1, => Clear + SetRange 1+ // Keys Navigated: Ctrl+Shift | n/a | Dst=item, Sel=Src => Clear + SetRange Src-Dst+ // Keys Activated: | n/a | Src=item, Sel=1 => Clear + SetRange 1+ // Keys Activated: Ctrl | n/a | Src=item, Sel=!Sel => SetSange 1+ // Keys Activated: Shift | n/a | Dst=item, Sel=1 => Clear + SetSange 1+ //----------------------------------------------------------------------------------------+ // Mouse Pressed: | n/a | Src=item, Sel=1, => Clear + SetRange 1+ // Mouse Pressed: Ctrl | n/a | Src=item, Sel=!Sel => SetRange 1+ // Mouse Pressed: Shift | n/a | Dst=item, Sel=1, => Clear + SetRange 1+ // Mouse Pressed: Ctrl+Shift | n/a | Dst=item, Sel=!Sel => SetRange Src-Dst+ //----------------------------------------------------------------------------------------++ if ((flags & ImGuiMultiSelectFlags_NoAutoClear) == 0)+ {+ bool request_clear = false;+ if (is_singleselect)+ request_clear = true;+ else if ((input_source == ImGuiInputSource_Mouse || g.NavActivateId == id) && !is_ctrl)+ request_clear = (flags & ImGuiMultiSelectFlags_NoAutoClearOnReselect) ? !selected : true;+ else if ((input_source == ImGuiInputSource_Keyboard || input_source == ImGuiInputSource_Gamepad) && is_shift && !is_ctrl)+ request_clear = true; // With is_shift==false the RequestClear was done in BeginIO, not necessary to do again.+ if (request_clear)+ MultiSelectAddSetAll(ms, false);+ }++ int range_direction;+ bool range_selected;+ if (is_shift && !is_singleselect)+ {+ //IM_ASSERT(storage->HasRangeSrc && storage->HasRangeValue);+ if (storage->RangeSrcItem == ImGuiSelectionUserData_Invalid)+ storage->RangeSrcItem = item_data;+ if ((flags & ImGuiMultiSelectFlags_CheckboxMode_) == 0)+ {+ // Shift+Arrow always select+ // Ctrl+Shift+Arrow copy source selection state (already stored by BeginMultiSelect() in storage->RangeSelected)+ range_selected = (is_ctrl && storage->RangeSelected != -1) ? (storage->RangeSelected != 0) : true;+ }+ else+ {+ // Shift+Arrow copy source selection state+ // Shift+Click always copy from target selection state+ if (ms->IsKeyboardSetRange)+ range_selected = (storage->RangeSelected != -1) ? (storage->RangeSelected != 0) : true;+ else+ range_selected = !selected;+ }+ range_direction = ms->RangeSrcPassedBy ? +1 : -1;+ }+ else+ {+ // Ctrl inverts selection, otherwise always select+ if ((flags & ImGuiMultiSelectFlags_CheckboxMode_) == 0)+ selected = is_ctrl ? !selected : true;+ else+ selected = !selected;+ storage->RangeSrcItem = item_data;+ range_selected = selected;+ range_direction = +1;+ }+ MultiSelectAddSetRange(ms, range_selected, range_direction, storage->RangeSrcItem, item_data);+ }++ // Update/store the selection state of the Source item (used by Ctrl+Shift, when Source is unselected we perform a range unselect)+ if (storage->RangeSrcItem == item_data)+ storage->RangeSelected = selected ? 1 : 0;++ // Update/store the selection state of focused item+ if (g.NavId == id)+ {+ storage->NavIdItem = item_data;+ storage->NavIdSelected = selected ? 1 : 0;+ }+ if (storage->NavIdItem == item_data)+ ms->NavIdPassedBy = true;++ *p_selected = selected;+ *p_pressed = pressed;+}++void ImGui::MultiSelectAddSetAll(ImGuiMultiSelectTempData* ms, bool selected)+{+ ImGuiSelectionRequest req = { ImGuiSelectionRequestType_SetAll, selected, 0, ImGuiSelectionUserData_Invalid, ImGuiSelectionUserData_Invalid };+ ms->IO.Requests.resize(0); // Can always clear previous requests+ ms->IO.Requests.push_back(req); // Add new request+}++void ImGui::MultiSelectAddSetRange(ImGuiMultiSelectTempData* ms, bool selected, int range_dir, ImGuiSelectionUserData first_item, ImGuiSelectionUserData last_item)+{+ // Merge contiguous spans into same request (unless NoRangeSelect is set which guarantees single-item ranges)+ // FIXME-OPT: Disabled on 2026/04/09 as this would break with any form of coarse clipping that we don't know about (e.g. TableNextColumn() return value).+ // The low-hanging fruit would be to know that ImGuiSelectionUserData are sequential indices, in which case we can trivially compare PrevSubmittedItem + RangeDir == FirstItem.+ // User can always perform this merge if required.+#if 0+ if (ms->IO.Requests.Size > 0 && first_item == last_item && (ms->Flags & ImGuiMultiSelectFlags_NoRangeSelect) == 0)+ {+ ImGuiSelectionRequest* prev = &ms->IO.Requests.Data[ms->IO.Requests.Size - 1];+ if (prev->Type == ImGuiSelectionRequestType_SetRange && prev->RangeLastItem == ms->PrevSubmittedItem && prev->Selected == selected)+ {+ prev->RangeLastItem = last_item;+ return;+ }+ }+#endif++ ImGuiSelectionRequest req = { ImGuiSelectionRequestType_SetRange, selected, (ImS8)range_dir, (range_dir > 0) ? first_item : last_item, (range_dir > 0) ? last_item : first_item };+ ms->IO.Requests.push_back(req); // Add new request+}++void ImGui::DebugNodeMultiSelectState(ImGuiMultiSelectState* storage)+{+#ifndef IMGUI_DISABLE_DEBUG_TOOLS+ const bool is_active = (storage->LastFrameActive >= GetFrameCount() - 2); // Note that fully clipped early out scrolling tables will appear as inactive here.+ if (!is_active) { PushStyleColor(ImGuiCol_Text, GetStyleColorVec4(ImGuiCol_TextDisabled)); }+ bool open = TreeNode((void*)(intptr_t)storage->ID, "MultiSelect 0x%08X in '%s'%s", storage->ID, storage->Window ? storage->Window->Name : "N/A", is_active ? "" : " *Inactive*");+ if (!is_active) { PopStyleColor(); }+ if (!open)+ return;+ Text("RangeSrcItem = %" IM_PRId64 " (0x%" IM_PRIX64 "), RangeSelected = %d", storage->RangeSrcItem, storage->RangeSrcItem, storage->RangeSelected);+ Text("NavIdItem = %" IM_PRId64 " (0x%" IM_PRIX64 "), NavIdSelected = %d", storage->NavIdItem, storage->NavIdItem, storage->NavIdSelected);+ Text("LastSelectionSize = %d", storage->LastSelectionSize); // Provided by user+ TreePop();+#else+ IM_UNUSED(storage);+#endif+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: Multi-Select helpers+//-------------------------------------------------------------------------+// - ImGuiSelectionBasicStorage+// - ImGuiSelectionExternalStorage+//-------------------------------------------------------------------------++ImGuiSelectionBasicStorage::ImGuiSelectionBasicStorage()+{+ Size = 0;+ PreserveOrder = false;+ UserData = NULL;+ AdapterIndexToStorageId = [](ImGuiSelectionBasicStorage*, int idx) { return (ImGuiID)idx; };+ _SelectionOrder = 1; // Always >0+}++void ImGuiSelectionBasicStorage::Clear()+{+ Size = 0;+ _SelectionOrder = 1; // Always >0+ _Storage.Data.resize(0);+}++void ImGuiSelectionBasicStorage::Swap(ImGuiSelectionBasicStorage& r)+{+ ImSwap(Size, r.Size);+ ImSwap(_SelectionOrder, r._SelectionOrder);+ _Storage.Data.swap(r._Storage.Data);+}++bool ImGuiSelectionBasicStorage::Contains(ImGuiID id) const+{+ return _Storage.GetInt(id, 0) != 0;+}++static int IMGUI_CDECL PairComparerByValueInt(const void* lhs, const void* rhs)+{+ int lhs_v = ((const ImGuiStoragePair*)lhs)->val_i;+ int rhs_v = ((const ImGuiStoragePair*)rhs)->val_i;+ return (lhs_v > rhs_v ? +1 : lhs_v < rhs_v ? -1 : 0);+}++// GetNextSelectedItem() is an abstraction allowing us to change our underlying actual storage system without impacting user.+// (e.g. store unselected vs compact down, compact down on demand, use raw ImVector<ImGuiID> instead of ImGuiStorage...)+bool ImGuiSelectionBasicStorage::GetNextSelectedItem(void** opaque_it, ImGuiID* out_id)+{+ ImGuiStoragePair* it = (ImGuiStoragePair*)*opaque_it;+ ImGuiStoragePair* it_end = _Storage.Data.Data + _Storage.Data.Size;+ if (PreserveOrder && it == NULL && it_end != NULL)+ ImQsort(_Storage.Data.Data, (size_t)_Storage.Data.Size, sizeof(ImGuiStoragePair), PairComparerByValueInt); // ~ImGuiStorage::BuildSortByValueInt()+ if (it == NULL)+ it = _Storage.Data.Data;+ IM_ASSERT(it >= _Storage.Data.Data && it <= it_end);+ if (it != it_end)+ while (it < it_end && it->val_i == 0)+ it++;+ const bool has_more = (it != it_end);+ *opaque_it = has_more ? (void**)(it + 1) : (void**)(it);+ *out_id = has_more ? it->key : 0;+ if (PreserveOrder && !has_more)+ _Storage.BuildSortByKey();+ return has_more;+}++void ImGuiSelectionBasicStorage::SetItemSelected(ImGuiID id, bool selected)+{+ int* p_int = _Storage.GetIntRef(id, 0);+ if (selected && *p_int == 0) { *p_int = _SelectionOrder++; Size++; }+ else if (!selected && *p_int != 0) { *p_int = 0; Size--; }+}++// Optimized for batch edits (with same value of 'selected')+static void ImGuiSelectionBasicStorage_BatchSetItemSelected(ImGuiSelectionBasicStorage* selection, ImGuiID id, bool selected, int size_before_amends, int selection_order)+{+ ImGuiStorage* storage = &selection->_Storage;+ ImGuiStoragePair* it = ImLowerBound(storage->Data.Data, storage->Data.Data + size_before_amends, id);+ const bool is_contained = (it != storage->Data.Data + size_before_amends) && (it->key == id);+ if (selected == (is_contained && it->val_i != 0))+ return;+ if (selected && !is_contained)+ storage->Data.push_back(ImGuiStoragePair(id, selection_order)); // Push unsorted at end of vector, will be sorted in SelectionMultiAmendsFinish()+ else if (is_contained)+ it->val_i = selected ? selection_order : 0; // Modify in-place.+ selection->Size += selected ? +1 : -1;+}++static void ImGuiSelectionBasicStorage_BatchFinish(ImGuiSelectionBasicStorage* selection, bool selected, int size_before_amends)+{+ ImGuiStorage* storage = &selection->_Storage;+ if (selected && selection->Size != size_before_amends)+ storage->BuildSortByKey(); // When done selecting: sort everything+}++// Apply requests coming from BeginMultiSelect() and EndMultiSelect().+// - Enable 'Demo->Tools->Debug Log->Selection' to see selection requests as they happen.+// - Honoring SetRange requests requires that you can iterate/interpolate between RangeFirstItem and RangeLastItem.+// - In this demo we often submit indices to SetNextItemSelectionUserData() + store the same indices in persistent selection.+// - Your code may do differently. If you store pointers or objects ID in ImGuiSelectionUserData you may need to perform+// a lookup in order to have some way to iterate/interpolate between two items.+// - A full-featured application is likely to allow search/filtering which is likely to lead to using indices+// and constructing a view index <> object id/ptr data structure anyway.+// WHEN YOUR APPLICATION SETTLES ON A CHOICE, YOU WILL PROBABLY PREFER TO GET RID OF THIS UNNECESSARY 'ImGuiSelectionBasicStorage' INDIRECTION LOGIC.+// Notice that with the simplest adapter (using indices everywhere), all functions return their parameters.+// The most simple implementation (using indices everywhere) would look like:+// for (ImGuiSelectionRequest& req : ms_io->Requests)+// {+// if (req.Type == ImGuiSelectionRequestType_SetAll) { Clear(); if (req.Selected) { for (int n = 0; n < items_count; n++) { SetItemSelected(n, true); } }+// if (req.Type == ImGuiSelectionRequestType_SetRange) { for (int n = (int)ms_io->RangeFirstItem; n <= (int)ms_io->RangeLastItem; n++) { SetItemSelected(n, ms_io->Selected); } }+// }+void ImGuiSelectionBasicStorage::ApplyRequests(ImGuiMultiSelectIO* ms_io)+{+ // For convenience we obtain ItemsCount as passed to BeginMultiSelect(), which is optional.+ // It makes sense when using ImGuiSelectionBasicStorage to simply pass your items count to BeginMultiSelect().+ // Other scheme may handle SetAll differently.+ IM_ASSERT(ms_io->ItemsCount != -1 && "Missing value for items_count in BeginMultiSelect() call!");+ IM_ASSERT(AdapterIndexToStorageId != NULL);++ // This is optimized/specialized to cope with very large selections (e.g. 100k+ items)+ // - A simpler version could call SetItemSelected() directly instead of ImGuiSelectionBasicStorage_BatchSetItemSelected() + ImGuiSelectionBasicStorage_BatchFinish().+ // - Optimized select can append unsorted, then sort in a second pass. Optimized unselect can clear in-place then compact in a second pass.+ // - A more optimal version wouldn't even use ImGuiStorage but directly a ImVector<ImGuiID> to reduce bandwidth, but this is a reasonable trade off to reuse code.+ // - There are many ways this could be better optimized. The worse case scenario being: using BoxSelect2d in a grid, box-select scrolling down while wiggling+ // left and right: it affects coarse clipping + can emit multiple SetRange with 1 item each.+ // FIXME-OPT: For each block of consecutive SetRange request:+ // - add all requests to a sorted list, store ID, selected, offset in ImGuiStorage.+ // - rewrite sorted storage a single time.+ for (ImGuiSelectionRequest& req : ms_io->Requests)+ {+ if (req.Type == ImGuiSelectionRequestType_SetAll)+ {+ Clear();+ if (req.Selected)+ {+ _Storage.Data.reserve(ms_io->ItemsCount);+ const int size_before_amends = _Storage.Data.Size;+ for (int idx = 0; idx < ms_io->ItemsCount; idx++, _SelectionOrder++)+ ImGuiSelectionBasicStorage_BatchSetItemSelected(this, GetStorageIdFromIndex(idx), req.Selected, size_before_amends, _SelectionOrder);+ ImGuiSelectionBasicStorage_BatchFinish(this, req.Selected, size_before_amends);+ }+ }+ else if (req.Type == ImGuiSelectionRequestType_SetRange)+ {+ const int selection_changes = (int)req.RangeLastItem - (int)req.RangeFirstItem + 1;+ //ImGuiContext& g = *GImGui; IMGUI_DEBUG_LOG_SELECTION("Req %d/%d: set %d to %d\n", ms_io->Requests.index_from_ptr(&req), ms_io->Requests.Size, selection_changes, req.Selected);+ if (selection_changes == 1 || (selection_changes < Size / 100))+ {+ // Multiple sorted insertion + copy likely to be faster.+ // Technically we could do a single copy with a little more work (sort sequential SetRange requests)+ for (int idx = (int)req.RangeFirstItem; idx <= (int)req.RangeLastItem; idx++)+ SetItemSelected(GetStorageIdFromIndex(idx), req.Selected);+ }+ else+ {+ // Append insertion + single sort likely be faster.+ // Use req.RangeDirection to set order field so that Shift+Clicking from 1 to 5 is different than Shift+Clicking from 5 to 1+ const int size_before_amends = _Storage.Data.Size;+ int selection_order = _SelectionOrder + ((req.RangeDirection < 0) ? selection_changes - 1 : 0);+ for (int idx = (int)req.RangeFirstItem; idx <= (int)req.RangeLastItem; idx++, selection_order += req.RangeDirection)+ ImGuiSelectionBasicStorage_BatchSetItemSelected(this, GetStorageIdFromIndex(idx), req.Selected, size_before_amends, selection_order);+ if (req.Selected)+ _SelectionOrder += selection_changes;+ ImGuiSelectionBasicStorage_BatchFinish(this, req.Selected, size_before_amends);+ }+ }+ }+}++//-------------------------------------------------------------------------++ImGuiSelectionExternalStorage::ImGuiSelectionExternalStorage()+{+ UserData = NULL;+ AdapterSetItemSelected = NULL;+}++// Apply requests coming from BeginMultiSelect() and EndMultiSelect().+// We also pull 'ms_io->ItemsCount' as passed for BeginMultiSelect() for consistency with ImGuiSelectionBasicStorage+// This makes no assumption about underlying storage.+void ImGuiSelectionExternalStorage::ApplyRequests(ImGuiMultiSelectIO* ms_io)+{+ IM_ASSERT(AdapterSetItemSelected);+ for (ImGuiSelectionRequest& req : ms_io->Requests)+ {+ if (req.Type == ImGuiSelectionRequestType_SetAll)+ for (int idx = 0; idx < ms_io->ItemsCount; idx++)+ AdapterSetItemSelected(this, idx, req.Selected);+ if (req.Type == ImGuiSelectionRequestType_SetRange)+ for (int idx = (int)req.RangeFirstItem; idx <= (int)req.RangeLastItem; idx++)+ AdapterSetItemSelected(this, idx, req.Selected);+ }+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: ListBox+//-------------------------------------------------------------------------+// - BeginListBox()+// - EndListBox()+// - ListBox()+//-------------------------------------------------------------------------++// This is essentially a thin wrapper to using BeginChild/EndChild with the ImGuiChildFlags_FrameStyle flag for stylistic changes + displaying a label.+// This handle some subtleties with capturing info from the label.+// If you don't need a label you can pretty much directly use ImGui::BeginChild() with ImGuiChildFlags_FrameStyle.+// Tip: To have a list filling the entire window width, use size.x = -FLT_MIN and pass an non-visible label e.g. "##empty"+// Tip: If your vertical size is calculated from an item count (e.g. 10 * item_height) consider adding a fractional part to facilitate seeing scrolling boundaries (e.g. 10.5f * item_height).+bool ImGui::BeginListBox(const char* label, const ImVec2& size_arg)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ const ImGuiStyle& style = g.Style;+ const ImGuiID id = GetID(label);+ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);++ // Size default to hold ~7.25 items.+ // Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar.+ ImVec2 size = ImTrunc(CalcItemSize(size_arg, CalcItemWidth(), GetTextLineHeightWithSpacing() * 7.25f + style.FramePadding.y * 2.0f));+ ImVec2 frame_size = ImVec2(size.x, ImMax(size.y, label_size.y));+ ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);+ ImRect bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));+ g.NextItemData.ClearFlags();++ if (!IsRectVisible(bb.Min, bb.Max))+ {+ ItemSize(bb.GetSize(), style.FramePadding.y);+ ItemAdd(bb, 0, &frame_bb);+ g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values+ return false;+ }++ // FIXME-OPT: We could omit the BeginGroup() if label_size.x == 0.0f but would need to omit the EndGroup() as well.+ BeginGroup();+ if (label_size.x > 0.0f)+ {+ ImVec2 label_pos = ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y);+ RenderText(label_pos, label, label_end, false);+ window->DC.CursorMaxPos = ImMax(window->DC.CursorMaxPos, label_pos + label_size);+ AlignTextToFramePadding();+ }++ BeginChild(id, frame_bb.GetSize(), ImGuiChildFlags_FrameStyle);+ return true;+}++void ImGui::EndListBox()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ IM_ASSERT((window->Flags & ImGuiWindowFlags_ChildWindow) && "Mismatched BeginListBox/EndListBox calls. Did you test the return value of BeginListBox?");+ IM_UNUSED(window);++ EndChild();+ EndGroup(); // This is only required to be able to do IsItemXXX query on the whole ListBox including label+}++bool ImGui::ListBox(const char* label, int* current_item, const char* const items[], int items_count, int height_items)+{+ const bool value_changed = ListBox(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_items);+ return value_changed;+}++// This is merely a helper around BeginListBox(), EndListBox().+// Considering using those directly to submit custom data or store selection differently.+bool ImGui::ListBox(const char* label, int* current_item, const char* (*getter)(void* user_data, int idx), void* user_data, int items_count, int height_in_items)+{+ ImGuiContext& g = *GImGui;++ // Calculate size from "height_in_items"+ if (height_in_items < 0)+ height_in_items = ImMin(items_count, 7);+ float height_in_items_f = height_in_items + 0.25f;+ ImVec2 size(0.0f, ImTrunc(GetTextLineHeightWithSpacing() * height_in_items_f + g.Style.FramePadding.y * 2.0f));++ if (!BeginListBox(label, size))+ return false;++ // Assume all items have even height (= 1 line of text). If you need items of different height,+ // you can create a custom version of ListBox() in your code without using the clipper.+ bool value_changed = false;+ ImGuiListClipper clipper;+ clipper.Begin(items_count, GetTextLineHeightWithSpacing()); // We know exactly our line height here so we pass it as a minor optimization, but generally you don't need to.+ clipper.IncludeItemByIndex(*current_item);+ while (clipper.Step())+ for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)+ {+ const char* item_text = getter(user_data, i);+ if (item_text == NULL)+ item_text = "*Unknown item*";++ PushID(i);+ const bool item_selected = (i == *current_item);+ if (Selectable(item_text, item_selected))+ {+ *current_item = i;+ value_changed = true;+ }+ if (item_selected)+ SetItemDefaultFocus();+ PopID();+ }+ EndListBox();++ if (value_changed)+ MarkItemEdited(g.LastItemData.ID);++ return value_changed;+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: PlotLines, PlotHistogram+//-------------------------------------------------------------------------+// - PlotEx() [Internal]+// - PlotLines()+// - PlotHistogram()+//-------------------------------------------------------------------------+// Plot/Graph widgets are not very good.+// Consider using ImPlot (https://github.com/epezent/implot) which is much better!+//-------------------------------------------------------------------------++int ImGui::PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, const ImVec2& size_arg)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return -1;++ const ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);++ const char* label_end = FindRenderedTextEnd(label);+ const ImVec2 label_size = CalcTextSize(label, label_end, false);+ const ImVec2 frame_size = CalcItemSize(size_arg, CalcItemWidth(), label_size.y + style.FramePadding.y * 2.0f);++ const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);+ const ImRect inner_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);+ const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0));+ ItemSize(total_bb, style.FramePadding.y);+ if (!ItemAdd(total_bb, id, &frame_bb, ImGuiItemFlags_NoNav))+ return -1;+ bool hovered;+ ButtonBehavior(frame_bb, id, &hovered, NULL);++ // Determine scale from values if not specified+ if (scale_min == FLT_MAX || scale_max == FLT_MAX)+ {+ float v_min = FLT_MAX;+ float v_max = -FLT_MAX;+ for (int i = 0; i < values_count; i++)+ {+ const float v = values_getter(data, i);+ if (v != v) // Ignore NaN values+ continue;+ v_min = ImMin(v_min, v);+ v_max = ImMax(v_max, v);+ }+ if (scale_min == FLT_MAX)+ scale_min = v_min;+ if (scale_max == FLT_MAX)+ scale_max = v_max;+ }++ RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);++ const int values_count_min = (plot_type == ImGuiPlotType_Lines) ? 2 : 1;+ int idx_hovered = -1;+ if (values_count >= values_count_min)+ {+ int res_w = ImMin((int)frame_size.x, values_count) + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);+ int item_count = values_count + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);++ // Tooltip on hover+ if (hovered && inner_bb.Contains(g.IO.MousePos))+ {+ const float t = ImClamp((g.IO.MousePos.x - inner_bb.Min.x) / (inner_bb.Max.x - inner_bb.Min.x), 0.0f, 0.999f);+ const int v_idx = (int)(t * item_count);+ IM_ASSERT(v_idx >= 0 && v_idx < values_count);++ const float v0 = values_getter(data, (v_idx + values_offset) % values_count);+ const float v1 = values_getter(data, (v_idx + 1 + values_offset) % values_count);+ if (plot_type == ImGuiPlotType_Lines)+ SetTooltip("%d: %8.4g\n%d: %8.4g", v_idx, v0, v_idx + 1, v1);+ else if (plot_type == ImGuiPlotType_Histogram)+ SetTooltip("%d: %8.4g", v_idx, v0);+ idx_hovered = v_idx;+ }++ const float t_step = 1.0f / (float)res_w;+ const float inv_scale = (scale_min == scale_max) ? 0.0f : (1.0f / (scale_max - scale_min));++ float v0 = values_getter(data, (0 + values_offset) % values_count);+ float t0 = 0.0f;+ ImVec2 tp0 = ImVec2( t0, 1.0f - ImSaturate((v0 - scale_min) * inv_scale) ); // Point in the normalized space of our target rectangle+ float histogram_zero_line_t = (scale_min * scale_max < 0.0f) ? (1 + scale_min * inv_scale) : (scale_min < 0.0f ? 0.0f : 1.0f); // Where does the zero line stands++ const ImU32 col_base = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLines : ImGuiCol_PlotHistogram);+ const ImU32 col_hovered = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLinesHovered : ImGuiCol_PlotHistogramHovered);++ for (int n = 0; n < res_w; n++)+ {+ const float t1 = t0 + t_step;+ const int v1_idx = (int)(t0 * item_count + 0.5f);+ IM_ASSERT(v1_idx >= 0 && v1_idx < values_count);+ const float v1 = values_getter(data, (v1_idx + values_offset + 1) % values_count);+ const ImVec2 tp1 = ImVec2( t1, 1.0f - ImSaturate((v1 - scale_min) * inv_scale) );++ // We could render lower-level to save a bit of CPU.+ ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, tp0);+ ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, (plot_type == ImGuiPlotType_Lines) ? tp1 : ImVec2(tp1.x, histogram_zero_line_t));+ if (plot_type == ImGuiPlotType_Lines)+ {+ window->DrawList->AddLine(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base);+ }+ else if (plot_type == ImGuiPlotType_Histogram)+ {+ if (pos1.x >= pos0.x + 2.0f)+ pos1.x -= 1.0f;+ if (pos0.y > pos1.y)+ ImSwap(pos0.y, pos1.y);+ window->DrawList->AddRectFilled(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base);+ }++ t0 = t1;+ tp0 = tp1;+ }+ }++ // Text overlay+ if (overlay_text)+ RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, overlay_text, NULL, NULL, ImVec2(0.5f, 0.0f));++ if (label_size.x > 0.0f)+ RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, inner_bb.Min.y), label, label_end, false);++ // Return hovered index or -1 if none are hovered.+ // This is currently not exposed in the public API because we need a larger redesign of the whole thing, but in the short-term we are making it available in PlotEx().+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ return idx_hovered;+}++struct ImGuiPlotArrayGetterData+{+ const float* Values;+ int Stride;++ ImGuiPlotArrayGetterData(const float* values, int stride) { Values = values; Stride = stride; }+};++static float Plot_ArrayGetter(void* data, int idx)+{+ ImGuiPlotArrayGetterData* plot_data = (ImGuiPlotArrayGetterData*)data;+ const float v = *(const float*)(const void*)((const unsigned char*)plot_data->Values + (size_t)idx * plot_data->Stride);+ return v;+}++void ImGui::PlotLines(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride)+{+ ImGuiPlotArrayGetterData data(values, stride);+ PlotEx(ImGuiPlotType_Lines, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);+}++void ImGui::PlotLines(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size)+{+ PlotEx(ImGuiPlotType_Lines, label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);+}++// Plot Histogram (the data provided _is_ histogram data. it doesn't compute the histogram of your data)+void ImGui::PlotHistogram(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride)+{+ ImGuiPlotArrayGetterData data(values, stride);+ PlotEx(ImGuiPlotType_Histogram, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);+}++void ImGui::PlotHistogram(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size)+{+ PlotEx(ImGuiPlotType_Histogram, label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: Value helpers+// Those is not very useful, legacy API.+//-------------------------------------------------------------------------+// - Value()+//-------------------------------------------------------------------------++void ImGui::Value(const char* prefix, bool b)+{+ Text("%s: %s", prefix, (b ? "true" : "false"));+}++void ImGui::Value(const char* prefix, int v)+{+ Text("%s: %d", prefix, v);+}++void ImGui::Value(const char* prefix, unsigned int v)+{+ Text("%s: %d", prefix, v);+}++void ImGui::Value(const char* prefix, float v, const char* float_format)+{+ if (float_format)+ {+ char fmt[64];+ ImFormatString(fmt, IM_COUNTOF(fmt), "%%s: %s", float_format);+ Text(fmt, prefix, v);+ }+ else+ {+ Text("%s: %.3f", prefix, v);+ }+}++//-------------------------------------------------------------------------+// [SECTION] MenuItem, BeginMenu, EndMenu, etc.+//-------------------------------------------------------------------------+// - ImGuiMenuColumns [Internal]+// - BeginMenuBar()+// - EndMenuBar()+// - BeginMainMenuBar()+// - EndMainMenuBar()+// - BeginMenu()+// - EndMenu()+// - MenuItemEx() [Internal]+// - MenuItem()+//-------------------------------------------------------------------------++// Helpers for internal use+void ImGuiMenuColumns::Update(float spacing, bool window_reappearing)+{+ if (window_reappearing)+ memset(Widths, 0, sizeof(Widths));+ Spacing = (ImU16)spacing;+ CalcNextTotalWidth(true);+ memset(Widths, 0, sizeof(Widths));+ TotalWidth = NextTotalWidth;+ NextTotalWidth = 0;+}++void ImGuiMenuColumns::CalcNextTotalWidth(bool update_offsets)+{+ ImU16 offset = 0;+ bool want_spacing = false;+ for (int i = 0; i < IM_COUNTOF(Widths); i++)+ {+ ImU16 width = Widths[i];+ if (want_spacing && width > 0)+ offset += Spacing;+ want_spacing |= (width > 0);+ if (update_offsets)+ {+ if (i == 1) { OffsetLabel = offset; }+ if (i == 2) { OffsetShortcut = offset; }+ if (i == 3) { OffsetMark = offset; }+ }+ offset += width;+ }+ NextTotalWidth = offset;+}++float ImGuiMenuColumns::DeclColumns(float w_icon, float w_label, float w_shortcut, float w_mark)+{+ Widths[0] = ImMax(Widths[0], (ImU16)w_icon);+ Widths[1] = ImMax(Widths[1], (ImU16)w_label);+ Widths[2] = ImMax(Widths[2], (ImU16)w_shortcut);+ Widths[3] = ImMax(Widths[3], (ImU16)w_mark);+ CalcNextTotalWidth(false);+ return (float)ImMax(TotalWidth, NextTotalWidth);+}++// FIXME: Provided a rectangle perhaps e.g. a BeginMenuBarEx() could be used anywhere..+// Currently the main responsibility of this function being to setup clip-rect + horizontal layout + menu navigation layer.+// Ideally we also want this to be responsible for claiming space out of the main window scrolling rectangle, in which case ImGuiWindowFlags_MenuBar will become unnecessary.+// Then later the same system could be used for multiple menu-bars, scrollbars, side-bars.+bool ImGui::BeginMenuBar()+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;+ if (!(window->Flags & ImGuiWindowFlags_MenuBar))+ return false;++ IM_ASSERT(!window->DC.MenuBarAppending);+ BeginGroup(); // Backup position on layer 0 // FIXME: Misleading to use a group for that backup/restore+ PushID("##MenuBar");++ // We don't clip with current window clipping rectangle as it is already set to the area below. However we clip with window full rect.+ // We remove 1 worth of rounding to Max.x to that text in long menus and small windows don't tend to display over the lower-right rounded area, which looks particularly glitchy.+ const float border_top = ImMax(window->WindowBorderSize * 0.5f - window->TitleBarHeight, 0.0f);+ ImRect bar_rect = window->MenuBarRect();+ ImRect clip_rect(IM_ROUND(bar_rect.Min.x + window->WindowBorderSize * 0.5f), IM_ROUND(bar_rect.Min.y + border_top), IM_ROUND(ImMax(bar_rect.Min.x, bar_rect.Max.x - ImMax(window->WindowRounding, window->WindowBorderSize * 0.5f))), IM_ROUND(bar_rect.Max.y));+ clip_rect.ClipWith(window->OuterRectClipped);+ PushClipRect(clip_rect.Min, clip_rect.Max, false);++ // We overwrite CursorMaxPos because BeginGroup sets it to CursorPos (essentially the .EmitItem hack in EndMenuBar() would need something analogous here, maybe a BeginGroupEx() with flags).+ window->DC.CursorPos = window->DC.CursorMaxPos = ImVec2(bar_rect.Min.x + window->DC.MenuBarOffset.x, bar_rect.Min.y + window->DC.MenuBarOffset.y);+ window->DC.LayoutType = ImGuiLayoutType_Horizontal;+ window->DC.IsSameLine = false;+ window->DC.NavLayerCurrent = ImGuiNavLayer_Menu;+ window->DC.MenuBarAppending = true;+ AlignTextToFramePadding();+ return true;+}++void ImGui::EndMenuBar()+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return;+ ImGuiContext& g = *GImGui;++ IM_MSVC_WARNING_SUPPRESS(6011); // Static Analysis false positive "warning C6011: Dereferencing NULL pointer 'window'"+ IM_ASSERT(window->Flags & ImGuiWindowFlags_MenuBar);+ IM_ASSERT(window->DC.MenuBarAppending);++ // Nav: When a move request within one of our child menu failed, capture the request to navigate among our siblings.+ if (NavMoveRequestButNoResultYet() && (g.NavMoveDir == ImGuiDir_Left || g.NavMoveDir == ImGuiDir_Right) && (g.NavWindow->Flags & ImGuiWindowFlags_ChildMenu))+ {+ // Try to find out if the request is for one of our child menu+ ImGuiWindow* nav_earliest_child = g.NavWindow;+ while (nav_earliest_child->ParentWindow && (nav_earliest_child->ParentWindow->Flags & ImGuiWindowFlags_ChildMenu))+ nav_earliest_child = nav_earliest_child->ParentWindow;+ if (nav_earliest_child->ParentWindow == window && nav_earliest_child->DC.ParentLayoutType == ImGuiLayoutType_Horizontal && (g.NavMoveFlags & ImGuiNavMoveFlags_Forwarded) == 0)+ {+ // To do so we claim focus back, restore NavId and then process the movement request for yet another frame.+ // This involve a one-frame delay which isn't very problematic in this situation. We could remove it by scoring in advance for multiple window (probably not worth bothering)+ const ImGuiNavLayer layer = ImGuiNavLayer_Menu;+ IM_ASSERT(window->DC.NavLayersActiveMaskNext & (1 << layer)); // Sanity check (FIXME: Seems unnecessary)+ FocusWindow(window);+ SetNavID(window->NavLastIds[layer], layer, 0, window->NavRectRel[layer]);+ // FIXME-NAV: How to deal with this when not using g.IO.ConfigNavCursorVisibleAuto?+ if (g.NavCursorVisible)+ {+ g.NavCursorVisible = false; // Hide nav cursor for the current frame so we don't see the intermediary selection. Will be set again+ g.NavCursorHideFrames = 2;+ }+ g.NavHighlightItemUnderNav = g.NavMousePosDirty = true;+ NavMoveRequestForward(g.NavMoveDir, g.NavMoveClipDir, g.NavMoveFlags, g.NavMoveScrollFlags); // Repeat+ }+ }+ else+ {+ NavMoveRequestTryWrapping(window, ImGuiNavMoveFlags_WrapX);+ }++ PopClipRect();+ PopID();+ IM_MSVC_WARNING_SUPPRESS(6011); // Static Analysis false positive "warning C6011: Dereferencing NULL pointer 'window'"+ window->DC.MenuBarOffset.x = window->DC.CursorPos.x - window->Pos.x; // Save horizontal position so next append can reuse it. This is kinda equivalent to a per-layer CursorPos.++ // FIXME: Extremely confusing, cleanup by (a) working on WorkRect stack system (b) not using a Group confusingly here.+ ImGuiGroupData& group_data = g.GroupStack.back();+ group_data.EmitItem = false;+ ImVec2 restore_cursor_max_pos = group_data.BackupCursorMaxPos;+ window->DC.IdealMaxPos.x = ImMax(window->DC.IdealMaxPos.x, window->DC.CursorMaxPos.x - window->Scroll.x); // Convert ideal extents for scrolling layer equivalent.+ EndGroup(); // Restore position on layer 0 // FIXME: Misleading to use a group for that backup/restore+ window->DC.LayoutType = ImGuiLayoutType_Vertical;+ window->DC.IsSameLine = false;+ window->DC.NavLayerCurrent = ImGuiNavLayer_Main;+ window->DC.MenuBarAppending = false;+ window->DC.CursorMaxPos = restore_cursor_max_pos;+}++// Important: calling order matters!+// FIXME: Somehow overlapping with docking tech.+// FIXME: The "rect-cut" aspect of this could be formalized into a lower-level helper (rect-cut: https://halt.software/dead-simple-layouts)+bool ImGui::BeginViewportSideBar(const char* name, ImGuiViewport* viewport_p, ImGuiDir dir, float axis_size, ImGuiWindowFlags window_flags)+{+ IM_ASSERT(dir != ImGuiDir_None);++ ImGuiWindow* bar_window = FindWindowByName(name);+ if (bar_window == NULL || bar_window->BeginCount == 0)+ {+ // Calculate and set window size/position+ ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)(viewport_p ? viewport_p : GetMainViewport());+ ImRect avail_rect = viewport->GetBuildWorkRect();+ ImGuiAxis axis = (dir == ImGuiDir_Up || dir == ImGuiDir_Down) ? ImGuiAxis_Y : ImGuiAxis_X;+ ImVec2 pos = avail_rect.Min;+ if (dir == ImGuiDir_Right || dir == ImGuiDir_Down)+ pos[axis] = avail_rect.Max[axis] - axis_size;+ ImVec2 size = avail_rect.GetSize();+ size[axis] = axis_size;+ SetNextWindowPos(pos);+ SetNextWindowSize(size);++ // Report our size into work area (for next frame) using actual window size+ if (dir == ImGuiDir_Up || dir == ImGuiDir_Left)+ viewport->BuildWorkInsetMin[axis] += axis_size;+ else if (dir == ImGuiDir_Down || dir == ImGuiDir_Right)+ viewport->BuildWorkInsetMax[axis] += axis_size;+ }++ window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;+ PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);+ PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0)); // Lift normal size constraint+ bool is_open = Begin(name, NULL, window_flags);+ PopStyleVar(2);++ return is_open;+}++bool ImGui::BeginMainMenuBar()+{+ ImGuiContext& g = *GImGui;+ ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)GetMainViewport();++ // For the main menu bar, which cannot be moved, we honor g.Style.DisplaySafeAreaPadding to ensure text can be visible on a TV set.+ // FIXME: This could be generalized as an opt-in way to clamp window->DC.CursorStartPos to avoid SafeArea?+ // FIXME: Consider removing support for safe area down the line... it's messy. Nowadays consoles have support for TV calibration in OS settings.+ g.NextWindowData.MenuBarOffsetMinVal = ImVec2(g.Style.DisplaySafeAreaPadding.x, ImMax(g.Style.DisplaySafeAreaPadding.y - g.Style.FramePadding.y, 0.0f));+ ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_MenuBar;+ float height = GetFrameHeight();+ bool is_open = BeginViewportSideBar("##MainMenuBar", viewport, ImGuiDir_Up, height, window_flags);+ g.NextWindowData.MenuBarOffsetMinVal = ImVec2(0.0f, 0.0f);+ if (!is_open)+ {+ End();+ return false;+ }++ // Temporarily disable _NoSavedSettings, in the off-chance that tables or child windows submitted within the menu-bar may want to use settings. (#8356)+ g.CurrentWindow->Flags &= ~ImGuiWindowFlags_NoSavedSettings;+ BeginMenuBar();+ return is_open;+}++void ImGui::EndMainMenuBar()+{+ ImGuiContext& g = *GImGui;+ IM_ASSERT_USER_ERROR_RET(g.CurrentWindow->DC.MenuBarAppending, "Calling EndMainMenuBar() not from a menu-bar!"); // Not technically testing that it is the main menu bar++ EndMenuBar();+ g.CurrentWindow->Flags |= ImGuiWindowFlags_NoSavedSettings; // Restore _NoSavedSettings (#8356)++ // When the user has left the menu layer (typically: closed menus through activation of an item), we restore focus to the previous window+ // FIXME: With this strategy we won't be able to restore a NULL focus.+ if (g.CurrentWindow == g.NavWindow && g.NavLayer == ImGuiNavLayer_Main && !g.NavAnyRequest && g.ActiveId == 0)+ FocusTopMostWindowUnderOne(g.NavWindow, NULL, NULL, ImGuiFocusRequestFlags_UnlessBelowModal | ImGuiFocusRequestFlags_RestoreFocusedChild);++ End();+}++static bool IsRootOfOpenMenuSet()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if ((g.OpenPopupStack.Size <= g.BeginPopupStack.Size) || (window->Flags & ImGuiWindowFlags_ChildMenu))+ return false;++ // Initially we used 'upper_popup->OpenParentId == window->IDStack.back()' to differentiate multiple menu sets from each others+ // (e.g. inside menu bar vs loose menu items) based on parent ID.+ // This would however prevent the use of e.g. PushID() user code submitting menus.+ // Previously this worked between popup and a first child menu because the first child menu always had the _ChildWindow flag,+ // making hovering on parent popup possible while first child menu was focused - but this was generally a bug with other side effects.+ // Instead we don't treat Popup specifically (in order to consistently support menu features in them), maybe the first child menu of a Popup+ // doesn't have the _ChildWindow flag, and we rely on this IsRootOfOpenMenuSet() check to allow hovering between root window/popup and first child menu.+ // In the end, lack of ID check made it so we could no longer differentiate between separate menu sets. To compensate for that, we at least check parent window nav layer.+ // This fixes the most common case of menu opening on hover when moving between window content and menu bar. Multiple different menu sets in same nav layer would still+ // open on hover, but that should be a lesser problem, because if such menus are close in proximity in window content then it won't feel weird and if they are far apart+ // it likely won't be a problem anyone runs into.+ const ImGuiPopupData* upper_popup = &g.OpenPopupStack[g.BeginPopupStack.Size];+ if (window->DC.NavLayerCurrent != upper_popup->ParentNavLayer)+ return false;+ return upper_popup->Window && (upper_popup->Window->Flags & ImGuiWindowFlags_ChildMenu) && ImGui::IsWindowChildOf(upper_popup->Window, window, true);+}++bool ImGui::BeginMenuEx(const char* label, const char* icon, bool enabled)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ ImGuiStyle& style = g.Style;+ const ImGuiID id = window->GetID(label);+ bool menu_is_open = IsPopupOpen(id, ImGuiPopupFlags_None);++ // Sub-menus are ChildWindow so that mouse can be hovering across them (otherwise top-most popup menu would steal focus and not allow hovering on parent menu)+ // The first menu in a hierarchy isn't so hovering doesn't get across (otherwise e.g. resizing borders with ImGuiButtonFlags_FlattenChildren would react), but top-most BeginMenu() will bypass that limitation.+ ImGuiWindowFlags window_flags = ImGuiWindowFlags_ChildMenu | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoNavFocus;+ if (window->Flags & ImGuiWindowFlags_ChildMenu)+ window_flags |= ImGuiWindowFlags_ChildWindow;++ // If a menu with same the ID was already submitted, we will append to it, matching the behavior of Begin().+ // We are relying on a O(N) search - so O(N log N) over the frame - which seems like the most efficient for the expected small amount of BeginMenu() calls per frame.+ // If somehow this is ever becoming a problem we can switch to use e.g. ImGuiStorage mapping key to last frame used.+ if (g.MenusIdSubmittedThisFrame.contains(id))+ {+ if (menu_is_open)+ menu_is_open = BeginPopupMenuEx(id, label, window_flags); // menu_is_open can be 'false' when the popup is completely clipped (e.g. zero size display)+ else+ g.NextWindowData.ClearFlags(); // we behave like Begin() and need to consume those values+ return menu_is_open;+ }++ // Tag menu as used. Next time BeginMenu() with same ID is called it will append to existing menu+ g.MenusIdSubmittedThisFrame.push_back(id);++ const char* label_end = FindRenderedTextEnd(label);+ ImVec2 label_size = CalcTextSize(label, label_end, false);++ // Odd hack to allow hovering across menus of a same menu-set (otherwise we wouldn't be able to hover parent without always being a Child window)+ // This is only done for items for the menu set and not the full parent window.+ const bool menuset_is_open = IsRootOfOpenMenuSet();+ if (menuset_is_open)+ g.NextItemData.ItemFlagsSet |= ImGuiItemFlags_NoWindowHoverableCheck;++ // The reference position stored in popup_pos will be used by Begin() to find a suitable position for the child menu,+ // However the final position is going to be different! It is chosen by FindBestWindowPosForPopup().+ // e.g. Menus tend to overlap each other horizontally to amplify relative Z-ordering.+ ImVec2 popup_pos;+ ImVec2 pos = window->DC.CursorPos;+ PushID(label);+ if (!enabled)+ BeginDisabled();++ bool pressed;++ const float backup_rounding = style.SelectableRounding;+ style.SelectableRounding = style.MenuItemRounding;+ const ImGuiSelectableFlags selectable_flags = ImGuiSelectableFlags_NoAutoClosePopups | (ImGuiSelectableFlags)ImGuiSelectableFlags_SelectOnClick;+ ImGuiMenuColumns* offsets = &window->DC.MenuColumns;+ if (window->DC.LayoutType == ImGuiLayoutType_Horizontal)+ {+ // Menu inside a horizontal menu bar+ // Selectable extend their highlight by half ItemSpacing in each direction.+ // For ChildMenu, the popup position will be overwritten by the call to FindBestWindowPosForPopup() in Begin()+ window->DC.CursorPos.x += IM_TRUNC(style.ItemSpacing.x * 0.5f);+ PushStyleVarX(ImGuiStyleVar_ItemSpacing, style.ItemSpacing.x * 2.0f);+ ImVec2 text_pos(window->DC.CursorPos.x + offsets->OffsetLabel, pos.y + window->DC.CurrLineTextBaseOffset);+ pressed = Selectable("", menu_is_open, selectable_flags, label_size);+ LogSetNextTextDecoration("[", "]");+ RenderText(text_pos, label, label_end, false);+ PopStyleVar();+ window->DC.CursorPos.x += IM_TRUNC(style.ItemSpacing.x * (-1.0f + 0.5f)); // -1 spacing to compensate the spacing added when Selectable() did a SameLine(). It would also work to call SameLine() ourselves after the PopStyleVar().+ popup_pos = ImVec2(pos.x - 1.0f - IM_TRUNC(style.ItemSpacing.x * 0.5f), text_pos.y - style.FramePadding.y + window->MenuBarHeight);+ }+ else+ {+ // Menu inside a regular/vertical menu+ // (In a typical menu window where all items are BeginMenu() or MenuItem() calls, extra_w will always be 0.0f.+ // Only when they are other items sticking out we're going to add spacing, yet only register minimum width into the layout system.)+ float icon_w = (icon && icon[0]) ? CalcTextSize(icon, NULL).x : 0.0f;+ float checkmark_w = IM_TRUNC(g.FontSize * 1.20f);+ float min_w = offsets->DeclColumns(icon_w, label_size.x, 0.0f, checkmark_w); // Feedback to next frame+ float extra_w = ImMax(0.0f, GetContentRegionAvail().x - min_w);+ ImVec2 text_pos(window->DC.CursorPos.x, pos.y + window->DC.CurrLineTextBaseOffset);+ pressed = Selectable("", menu_is_open, selectable_flags | ImGuiSelectableFlags_SpanAvailWidth, ImVec2(min_w, label_size.y));+ LogSetNextTextDecoration("", ">");+ RenderText(ImVec2(text_pos.x + offsets->OffsetLabel, text_pos.y), label, label_end, false);+ if (icon_w > 0.0f)+ RenderText(ImVec2(text_pos.x + offsets->OffsetIcon, text_pos.y), icon);+ if (BuiOn()) // BUI: the submenu triangle, drawn by the kit+ {+ BKWidgetDraw w = BuiWidget(BK_WIDGET_ARROW, ImRect(ImVec2(text_pos.x + offsets->OffsetMark + extra_w + g.FontSize * 0.30f, text_pos.y), ImVec2(text_pos.x + offsets->OffsetMark + extra_w + g.FontSize * 1.30f, text_pos.y + g.FontSize)), BK_WS_FLAT);+ BuiEmit(w);+ }+ else // BUI+ RenderArrow(window->DrawList, ImVec2(text_pos.x + offsets->OffsetMark + extra_w + g.FontSize * 0.30f, text_pos.y), GetColorU32(ImGuiCol_Text), ImGuiDir_Right);+ popup_pos = ImVec2(pos.x, text_pos.y - style.WindowPadding.y);+ }+ style.SelectableRounding = backup_rounding;+ if (!enabled)+ EndDisabled();++ // Once dragged, release ActiveId + key ownership. This is to allow the idiom of mouse down a menu, dragging elsewhere, up on some other MenuItem(). (#8233, #9394)+ // Could move logic into lower-level ImGuiButtonFlags_AutoReleaseActiveId + ImGuiButtonFlags_AutoReleaseKeyOwner? Easier once we get rid of the Selectable() middle-man here.+ if (g.ActiveId == id && g.HoveredId != id && g.ActiveIdSource == ImGuiInputSource_Mouse && IsMouseDragging(0))+ {+ ClearActiveID();+ SetKeyOwner(ImGuiKey_MouseLeft, ImGuiKeyOwner_NoOwner);+ }++ const bool hovered = (g.HoveredId == id) && enabled && !g.NavHighlightItemUnderNav;++ bool want_open = false;+ bool want_open_nav_init = false;+ bool want_close = false;+ if (window->DC.LayoutType == ImGuiLayoutType_Vertical) // (window->Flags & (ImGuiWindowFlags_Popup|ImGuiWindowFlags_ChildMenu))+ {+ // Close menu when not hovering it anymore unless we are moving roughly in the direction of the menu+ // Implement http://bjk5.com/post/44698559168/breaking-down-amazons-mega-dropdown to avoid using timers, so menus feels more reactive.+ bool moving_toward_child_menu = false;+ ImGuiPopupData* child_popup = (g.BeginPopupStack.Size < g.OpenPopupStack.Size) ? &g.OpenPopupStack[g.BeginPopupStack.Size] : NULL; // Popup candidate (testing below)+ ImGuiWindow* child_menu_window = (child_popup && child_popup->Window && child_popup->Window->ParentWindow == window) ? child_popup->Window : NULL;+ if (g.HoveredWindow == window && child_menu_window != NULL)+ {+ const float ref_unit = g.FontSize; // FIXME-DPI+ const float child_dir = (window->Pos.x < child_menu_window->Pos.x) ? 1.0f : -1.0f;+ const ImRect next_window_rect = child_menu_window->Rect();+ ImVec2 ta = (g.IO.MousePos - g.IO.MouseDelta);+ ImVec2 tb = (child_dir > 0.0f) ? next_window_rect.GetTL() : next_window_rect.GetTR();+ ImVec2 tc = (child_dir > 0.0f) ? next_window_rect.GetBL() : next_window_rect.GetBR();+ const float pad_farmost_h = ImClamp(ImFabs(ta.x - tb.x) * 0.30f, ref_unit * 0.5f, ref_unit * 2.5f); // Add a bit of extra slack.+ ta.x += child_dir * -0.5f;+ tb.x += child_dir * ref_unit;+ tc.x += child_dir * ref_unit;+ tb.y = ta.y + ImMax((tb.y - pad_farmost_h) - ta.y, -ref_unit * 8.0f); // Triangle has maximum height to limit the slope and the bias toward large sub-menus+ tc.y = ta.y + ImMin((tc.y + pad_farmost_h) - ta.y, +ref_unit * 8.0f);+ moving_toward_child_menu = ImTriangleContainsPoint(ta, tb, tc, g.IO.MousePos);+ //GetForegroundDrawList()->AddTriangleFilled(ta, tb, tc, moving_toward_child_menu ? IM_COL32(0,128,0,128) : IM_COL32(128,0,0,128)); // [DEBUG]+ }++ // The 'HovereWindow == window' check creates an inconsistency (e.g. moving away from menu slowly tends to hit same window, whereas moving away fast does not)+ // But we also need to not close the top-menu menu when moving over void. Perhaps we should extend the triangle check to a larger polygon.+ // (Remember to test this on BeginPopup("A")->BeginMenu("B") sequence which behaves slightly differently as B isn't a Child of A and hovering isn't shared.)+ if (menu_is_open && !hovered && g.HoveredWindow == window && !moving_toward_child_menu && !g.NavHighlightItemUnderNav && g.ActiveId == 0)+ want_close = true;++ // Open+ // (note: at this point 'hovered' actually includes the NavDisableMouseHover == false test)+ if (!menu_is_open && pressed) // Click/activate to open+ want_open = true;+ else if (!menu_is_open && hovered && !moving_toward_child_menu) // Hover to open+ want_open = true;+ else if (!menu_is_open && hovered && g.HoveredIdTimer >= 0.30f && g.MouseStationaryTimer >= 0.30f) // Hover to open (timer fallback)+ want_open = true;+ if (g.NavId == id && g.NavMoveDir == ImGuiDir_Right) // Nav-Right to open+ {+ want_open = want_open_nav_init = true;+ NavMoveRequestCancel();+ SetNavCursorVisibleAfterMove();+ }+ }+ else+ {+ // Menu bar+ if (menu_is_open && pressed && menuset_is_open) // Click an open menu again to close it+ {+ want_close = true;+ want_open = menu_is_open = false;+ }+ else if (pressed || (hovered && menuset_is_open && !menu_is_open)) // First click to open, then hover to open others+ {+ want_open = true;+ }+ else if (g.NavId == id && g.NavMoveDir == ImGuiDir_Down) // Nav-Down to open+ {+ want_open = true;+ NavMoveRequestCancel();+ }+ }++ if (!enabled) // explicitly close if an open menu becomes disabled, facilitate users code a lot in pattern such as 'if (BeginMenu("options", has_object)) { ..use object.. }'+ want_close = true;+ if (want_close && IsPopupOpen(id, ImGuiPopupFlags_None))+ ClosePopupToLevel(g.BeginPopupStack.Size, true);++ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Openable | (menu_is_open ? ImGuiItemStatusFlags_Opened : 0));+ PopID();++ if (g.ActiveId == id && want_open)+ g.ActiveIdNoClearOnFocusLoss = true;++ if (want_open && !menu_is_open && g.OpenPopupStack.Size > g.BeginPopupStack.Size)+ {+ // Don't reopen/recycle same menu level in the same frame if it is a different menu ID, first close the other menu and yield for a frame.+ OpenPopup(label);+ }+ else if (want_open)+ {+ menu_is_open = true;+ OpenPopup(label, ImGuiPopupFlags_NoReopen);// | (want_open_nav_init ? ImGuiPopupFlags_NoReopenAlwaysNavInit : 0));+ }++ if (menu_is_open)+ {+ ImGuiLastItemData last_item_in_parent = g.LastItemData;+ SetNextWindowPos(popup_pos, ImGuiCond_Always); // Note: misleading: the value will serve as reference for FindBestWindowPosForPopup(), not actual pos.+ PushStyleVar(ImGuiStyleVar_ChildRounding, style.PopupRounding); // First level will use _PopupRounding, subsequent will use _ChildRounding+ menu_is_open = BeginPopupMenuEx(id, label, window_flags); // menu_is_open may be 'false' when the popup is completely clipped (e.g. zero size display)+ PopStyleVar();+ if (menu_is_open)+ {+ if (BuiOn()) // BUI: Blender menu backdrop (with its shadow)+ BuiWindowBack(BK_WIDGET_MENU_BACK);+ // Implement what ImGuiPopupFlags_NoReopenAlwaysNavInit would do:+ // Perform an init request in the case the popup was already open (via a previous mouse hover)+ if (want_open && want_open_nav_init && !g.NavInitRequest)+ {+ FocusWindow(g.CurrentWindow, ImGuiFocusRequestFlags_UnlessBelowModal);+ NavInitWindow(g.CurrentWindow, false);+ }++ // Restore LastItemData so IsItemXXXX functions can work after BeginMenu()/EndMenu()+ // (This fixes using IsItemClicked() and IsItemHovered(), but IsItemHovered() also relies on its support for ImGuiItemFlags_NoWindowHoverableCheck)+ g.LastItemData = last_item_in_parent;+ if (g.HoveredWindow == window)+ g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HoveredWindow;+ }+ }+ else+ {+ g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values+ }++ return menu_is_open;+}++bool ImGui::BeginMenu(const char* label, bool enabled)+{+ return BeginMenuEx(label, NULL, enabled);+}++void ImGui::EndMenu()+{+ // Nav: When a left move request our menu failed, close ourselves.+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ IM_ASSERT_USER_ERROR_RET((window->Flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu)) == (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu), "Calling EndMenu() in wrong window!");++ ImGuiWindow* parent_window = window->ParentWindow; // Should always be != NULL is we passed assert.+ if (window->BeginCount == window->BeginCountPreviousFrame)+ if (g.NavMoveDir == ImGuiDir_Left && NavMoveRequestButNoResultYet())+ if (g.NavWindow && (g.NavWindow->RootWindowForNav == window) && parent_window->DC.LayoutType == ImGuiLayoutType_Vertical)+ {+ ClosePopupToLevel(g.BeginPopupStack.Size - 1, true);+ NavMoveRequestCancel();+ }++ EndPopup();+}++bool ImGui::MenuItemEx(const char* label, const char* icon, const char* shortcut, bool selected, bool enabled)+{+ ImGuiWindow* window = GetCurrentWindow();+ if (window->SkipItems)+ return false;++ ImGuiContext& g = *GImGui;+ ImGuiStyle& style = g.Style;+ ImVec2 pos = window->DC.CursorPos;+ const char* label_end = FindRenderedTextEnd(label);+ ImVec2 label_size = CalcTextSize(label, label_end, false);++ // See BeginMenuEx() for comments about this.+ const bool menuset_is_open = IsRootOfOpenMenuSet();+ if (menuset_is_open)+ g.NextItemData.ItemFlagsSet |= ImGuiItemFlags_NoWindowHoverableCheck;++ // We've been using the equivalent of ImGuiSelectableFlags_SetNavIdOnHover on all Selectable() since early Nav system days (commit 43ee5d73),+ // but I am unsure whether this should be kept at all. For now moved it to be an opt-in feature used by menus only.+ bool pressed;+ PushID(label);+ if (!enabled)+ BeginDisabled();++ // We use ImGuiSelectableFlags_NoSetKeyOwner to allow down on one menu item, move, up on another.+ const float backup_rounding = style.SelectableRounding;+ style.SelectableRounding = style.MenuItemRounding;+ const ImGuiSelectableFlags selectable_flags = (ImGuiSelectableFlags)ImGuiSelectableFlags_SelectOnRelease | (ImGuiSelectableFlags)ImGuiSelectableFlags_SetNavIdOnHover;+ ImGuiMenuColumns* offsets = &window->DC.MenuColumns;+ if (window->DC.LayoutType == ImGuiLayoutType_Horizontal)+ {+ // Mimic the exact layout spacing of BeginMenu() to allow MenuItem() inside a menu bar, which is a little misleading but may be useful+ // Note that in this situation: we don't render the shortcut, we render a highlight instead of the selected tick mark.+ window->DC.CursorPos.x += IM_TRUNC(style.ItemSpacing.x * 0.5f);+ ImVec2 text_pos(window->DC.CursorPos.x + offsets->OffsetLabel, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);+ PushStyleVarX(ImGuiStyleVar_ItemSpacing, style.ItemSpacing.x * 2.0f);+ pressed = Selectable("", selected, selectable_flags, ImVec2(label_size.x, 0.0f));+ PopStyleVar();+ if (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_Visible)+ RenderText(text_pos, label, label_end, false);+ window->DC.CursorPos.x += IM_TRUNC(style.ItemSpacing.x * (-1.0f + 0.5f)); // -1 spacing to compensate the spacing added when Selectable() did a SameLine(). It would also work to call SameLine() ourselves after the PopStyleVar().+ }+ else+ {+ // Menu item inside a vertical menu+ // (In a typical menu window where all items are BeginMenu() or MenuItem() calls, extra_w will always be 0.0f.+ // Only when they are other items sticking out we're going to add spacing, yet only register minimum width into the layout system.)+ float icon_w = (icon && icon[0]) ? CalcTextSize(icon, NULL).x : 0.0f;+ float shortcut_w = (shortcut && shortcut[0]) ? CalcTextSize(shortcut, NULL).x : 0.0f;+ float checkmark_w = IM_TRUNC(g.FontSize * 1.20f); // FIXME: Always accounted for, even in a menu with none, because 'selected' has no neutral setting.+ float min_w = offsets->DeclColumns(icon_w, label_size.x, shortcut_w, checkmark_w); // Feedback for next frame+ float stretch_w = ImMax(0.0f, GetContentRegionAvail().x - min_w);+ ImVec2 text_pos(pos.x, pos.y + window->DC.CurrLineTextBaseOffset);+ pressed = Selectable("", false, selectable_flags | ImGuiSelectableFlags_SpanAvailWidth, ImVec2(min_w, label_size.y));+ if (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_Visible)+ {+ RenderText(text_pos + ImVec2(offsets->OffsetLabel, 0.0f), label, label_end, false);+ if (icon_w > 0.0f)+ RenderText(text_pos + ImVec2(offsets->OffsetIcon, 0.0f), icon);+ if (shortcut_w > 0.0f)+ {+ PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]);+ LogSetNextTextDecoration("(", ")");+ RenderText(text_pos + ImVec2(offsets->OffsetShortcut + stretch_w, 0.0f), shortcut, NULL, false);+ PopStyleColor();+ }+ if (selected && BuiOn()) // BUI: Blender's menu check box (menu_check_icon: 0.6 units, checked)+ {+ const float sz = IM_TRUNC(GetFrameHeight() * 0.6f);+ const ImVec2 c = text_pos + ImVec2(offsets->OffsetMark + stretch_w + g.FontSize * 0.40f + g.FontSize * 0.433f, g.FontSize * 0.5f);+ BuiEmit(BuiWidget(BK_WIDGET_CHECKBOX, ImRect(ImTrunc(c - ImVec2(sz * 0.5f, sz * 0.5f)), ImTrunc(c - ImVec2(sz * 0.5f, sz * 0.5f)) + ImVec2(sz, sz)), BK_WS_SELECTED));+ }+ else if (selected) // BUI+ RenderCheckMark(window->DrawList, text_pos + ImVec2(offsets->OffsetMark + stretch_w + g.FontSize * 0.40f, g.FontSize * 0.134f * 0.5f), GetColorU32(ImGuiCol_Text), g.FontSize * 0.866f);+ }+ }+ style.SelectableRounding = backup_rounding;++ // Once dragged, release ActiveId + key ownership. This is to allow the idiom of mouse down a menu, dragging elsewhere, up on some other MenuItem(). (#8233, #9394)+ // Could move logic into lower-level ImGuiButtonFlags_AutoReleaseActiveId + ImGuiButtonFlags_AutoReleaseKeyOwner? Easier once we get rid of the Selectable() middle-man here.+ const ImGuiID id = g.LastItemData.ID;+ if (g.ActiveId == id && g.HoveredId != id && g.ActiveIdSource == ImGuiInputSource_Mouse && IsMouseDragging(0))+ {+ ClearActiveID();+ SetKeyOwner(ImGuiKey_MouseLeft, ImGuiKeyOwner_NoOwner);+ }+++ IMGUI_TEST_ENGINE_ITEM_INFO(g.LastItemData.ID, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Checkable | (selected ? ImGuiItemStatusFlags_Checked : 0));+ if (!enabled)+ EndDisabled();+ PopID();++ return pressed;+}++bool ImGui::MenuItem(const char* label, const char* shortcut, bool selected, bool enabled)+{+ return MenuItemEx(label, NULL, shortcut, selected, enabled);+}++bool ImGui::MenuItem(const char* label, const char* shortcut, bool* p_selected, bool enabled)+{+ if (MenuItemEx(label, NULL, shortcut, p_selected ? *p_selected : false, enabled))+ {+ if (p_selected)+ *p_selected = !*p_selected;+ return true;+ }+ return false;+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: BeginTabBar, EndTabBar, etc.+//-------------------------------------------------------------------------+// - BeginTabBar()+// - BeginTabBarEx() [Internal]+// - EndTabBar()+// - TabBarLayout() [Internal]+// - TabBarCalcTabID() [Internal]+// - TabBarCalcMaxTabWidth() [Internal]+// - TabBarFindTabById() [Internal]+// - TabBarFindTabByOrder() [Internal]+// - TabBarGetCurrentTab() [Internal]+// - TabBarGetTabName() [Internal]+// - TabBarRemoveTab() [Internal]+// - TabBarCloseTab() [Internal]+// - TabBarScrollClamp() [Internal]+// - TabBarScrollToTab() [Internal]+// - TabBarQueueFocus() [Internal]+// - TabBarQueueReorder() [Internal]+// - TabBarProcessReorderFromMousePos() [Internal]+// - TabBarProcessReorder() [Internal]+// - TabBarScrollingButtons() [Internal]+// - TabBarTabListPopupButton() [Internal]+//-------------------------------------------------------------------------++struct ImGuiTabBarSection+{+ int TabCount; // Number of tabs in this section.+ float Width; // Sum of width of tabs in this section (after shrinking down)+ float WidthAfterShrinkMinWidth;+ float Spacing; // Horizontal spacing at the end of the section.++ ImGuiTabBarSection() { memset((void*)this, 0, sizeof(*this)); }+};++namespace ImGui+{+ static void TabBarLayout(ImGuiTabBar* tab_bar);+ static ImU32 TabBarCalcTabID(ImGuiTabBar* tab_bar, const char* label, ImGuiWindow* docked_window);+ static float TabBarCalcMaxTabWidth();+ static float TabBarScrollClamp(ImGuiTabBar* tab_bar, float scrolling);+ static void TabBarScrollToTab(ImGuiTabBar* tab_bar, ImGuiID tab_id, ImGuiTabBarSection* sections);+ static ImGuiTabItem* TabBarScrollingButtons(ImGuiTabBar* tab_bar);+ static ImGuiTabItem* TabBarTabListPopupButton(ImGuiTabBar* tab_bar);+}++ImGuiTabBar::ImGuiTabBar()+{+ memset((void*)this, 0, sizeof(*this));+ CurrFrameVisible = PrevFrameVisible = -1;+ LastTabItemIdx = -1;+}++static inline int TabItemGetSectionIdx(const ImGuiTabItem* tab)+{+ return (tab->Flags & ImGuiTabItemFlags_Leading) ? 0 : (tab->Flags & ImGuiTabItemFlags_Trailing) ? 2 : 1;+}++static int IMGUI_CDECL TabItemComparerBySection(const void* lhs, const void* rhs)+{+ const ImGuiTabItem* a = (const ImGuiTabItem*)lhs;+ const ImGuiTabItem* b = (const ImGuiTabItem*)rhs;+ const int a_section = TabItemGetSectionIdx(a);+ const int b_section = TabItemGetSectionIdx(b);+ if (a_section != b_section)+ return a_section - b_section;+ return (int)(a->IndexDuringLayout - b->IndexDuringLayout);+}++static int IMGUI_CDECL TabItemComparerByBeginOrder(const void* lhs, const void* rhs)+{+ const ImGuiTabItem* a = (const ImGuiTabItem*)lhs;+ const ImGuiTabItem* b = (const ImGuiTabItem*)rhs;+ return (int)(a->BeginOrder - b->BeginOrder);+}++static ImGuiTabBar* GetTabBarFromTabBarRef(const ImGuiPtrOrIndex& ref)+{+ ImGuiContext& g = *GImGui;+ return ref.Ptr ? (ImGuiTabBar*)ref.Ptr : g.TabBars.GetByIndex(ref.Index);+}++static ImGuiPtrOrIndex GetTabBarRefFromTabBar(ImGuiTabBar* tab_bar)+{+ ImGuiContext& g = *GImGui;+ if (g.TabBars.Contains(tab_bar))+ return ImGuiPtrOrIndex(g.TabBars.GetIndex(tab_bar));+ return ImGuiPtrOrIndex(tab_bar);+}++ImGuiTabBar* ImGui::TabBarFindByID(ImGuiID id)+{+ ImGuiContext& g = *GImGui;+ return g.TabBars.GetByKey(id);+}++// Remove TabBar data (currently only used by TestEngine)+void ImGui::TabBarRemove(ImGuiTabBar* tab_bar)+{+ ImGuiContext& g = *GImGui;+ g.TabBars.Remove(tab_bar->ID, tab_bar);+}++bool ImGui::BeginTabBar(const char* str_id, ImGuiTabBarFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return false;++ ImGuiID id = window->GetID(str_id);+ ImGuiTabBar* tab_bar = g.TabBars.GetOrAddByKey(id);+ ImRect tab_bar_bb = ImRect(window->DC.CursorPos.x, window->DC.CursorPos.y, window->WorkRect.Max.x, window->DC.CursorPos.y + g.FontSize + g.Style.FramePadding.y * 2);+ tab_bar->ID = id;+ tab_bar->SeparatorMinX = tab_bar_bb.Min.x - IM_TRUNC(window->WindowPadding.x * 0.5f);+ tab_bar->SeparatorMaxX = tab_bar_bb.Max.x + IM_TRUNC(window->WindowPadding.x * 0.5f);+ //if (g.NavWindow && IsWindowChildOf(g.NavWindow, window, false, false))+ flags |= ImGuiTabBarFlags_IsFocused;+ return BeginTabBarEx(tab_bar, tab_bar_bb, flags);+}++bool ImGui::BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& tab_bar_bb, ImGuiTabBarFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return false;++ IM_ASSERT(tab_bar->ID != 0);+ if ((flags & ImGuiTabBarFlags_DockNode) == 0)+ PushOverrideID(tab_bar->ID);++ // Add to stack+ g.CurrentTabBarStack.push_back(GetTabBarRefFromTabBar(tab_bar));+ g.CurrentTabBar = tab_bar;+ tab_bar->Window = window;++ // Append with multiple BeginTabBar()/EndTabBar() pairs.+ tab_bar->BackupCursorPos = window->DC.CursorPos;+ if (tab_bar->CurrFrameVisible == g.FrameCount)+ {+ window->DC.CursorPos = ImVec2(tab_bar->BarRect.Min.x, tab_bar->BarRect.Max.y + tab_bar->ItemSpacingY);+ tab_bar->BeginCount++;+ return true;+ }++ // Ensure correct ordering when toggling ImGuiTabBarFlags_Reorderable flag, or when a new tab was added while being not reorderable+ if ((flags & ImGuiTabBarFlags_Reorderable) != (tab_bar->Flags & ImGuiTabBarFlags_Reorderable) || (tab_bar->TabsAddedNew && !(flags & ImGuiTabBarFlags_Reorderable)))+ ImQsort(tab_bar->Tabs.Data, tab_bar->Tabs.Size, sizeof(ImGuiTabItem), TabItemComparerByBeginOrder);+ tab_bar->TabsAddedNew = false;++ // Flags+ if ((flags & ImGuiTabBarFlags_FittingPolicyMask_) == 0)+ flags |= ImGuiTabBarFlags_FittingPolicyDefault_;++ tab_bar->Flags = flags;+ tab_bar->BarRect = tab_bar_bb;+ tab_bar->WantLayout = true; // Layout will be done on the first call to ItemTab()+ tab_bar->PrevFrameVisible = tab_bar->CurrFrameVisible;+ tab_bar->CurrFrameVisible = g.FrameCount;+ tab_bar->PrevTabsContentsHeight = tab_bar->CurrTabsContentsHeight;+ tab_bar->CurrTabsContentsHeight = 0.0f;+ tab_bar->ItemSpacingY = g.Style.ItemSpacing.y;+ tab_bar->FramePadding = g.Style.FramePadding;+ tab_bar->TabsActiveCount = 0;+ tab_bar->LastTabItemIdx = -1;+ tab_bar->BeginCount = 1;++ // Set cursor pos in a way which only be used in the off-chance the user erroneously submits item before BeginTabItem(): items will overlap+ window->DC.CursorPos = ImVec2(tab_bar->BarRect.Min.x, tab_bar->BarRect.Max.y + tab_bar->ItemSpacingY);++ // Draw separator+ // (it would be misleading to draw this in EndTabBar() suggesting that it may be drawn over tabs, as tab bar are appendable)+ const ImU32 col = GetColorU32((flags & ImGuiTabBarFlags_IsFocused) ? ImGuiCol_TabSelected : ImGuiCol_TabDimmedSelected);+ if (g.Style.TabBarBorderSize > 0.0f)+ {+ const float y = tab_bar->BarRect.Max.y;+ window->DrawList->AddRectFilled(ImVec2(tab_bar->SeparatorMinX, y - g.Style.TabBarBorderSize), ImVec2(tab_bar->SeparatorMaxX, y), col);+ }+ return true;+}++void ImGui::EndTabBar()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return;++ ImGuiTabBar* tab_bar = g.CurrentTabBar;+ IM_ASSERT_USER_ERROR_RET(tab_bar != NULL, "Mismatched BeginTabBar()/EndTabBar()!");++ // Fallback in case no TabItem have been submitted+ if (tab_bar->WantLayout)+ TabBarLayout(tab_bar);++ // Restore the last visible height if no tab is visible, this reduce vertical flicker/movement when a tabs gets removed without calling SetTabItemClosed().+ const bool tab_bar_appearing = (tab_bar->PrevFrameVisible + 1 < g.FrameCount);+ if (tab_bar->VisibleTabWasSubmitted || tab_bar->VisibleTabContentsId == 0 || tab_bar_appearing)+ {+ tab_bar->CurrTabsContentsHeight = ImMax(window->DC.CursorPos.y - tab_bar->BarRect.Max.y, tab_bar->CurrTabsContentsHeight);+ window->DC.CursorPos.y = tab_bar->BarRect.Max.y + tab_bar->CurrTabsContentsHeight;+ }+ else+ {+ window->DC.CursorPos.y = tab_bar->BarRect.Max.y + tab_bar->PrevTabsContentsHeight;+ }+ if (tab_bar->BeginCount > 1)+ window->DC.CursorPos = tab_bar->BackupCursorPos;++ tab_bar->LastTabItemIdx = -1;+ if ((tab_bar->Flags & ImGuiTabBarFlags_DockNode) == 0)+ PopID();++ g.CurrentTabBarStack.pop_back();+ g.CurrentTabBar = g.CurrentTabBarStack.empty() ? NULL : GetTabBarFromTabBarRef(g.CurrentTabBarStack.back());+}++// Scrolling happens only in the central section (leading/trailing sections are not scrolling)+static float TabBarCalcScrollableWidth(ImGuiTabBar* tab_bar, ImGuiTabBarSection* sections)+{+ return tab_bar->BarRect.GetWidth() - sections[0].Width - sections[2].Width - sections[1].Spacing;+}++// This is called only once a frame before by the first call to ItemTab()+// The reason we're not calling it in BeginTabBar() is to leave a chance to the user to call the SetTabItemClosed() functions.+static void ImGui::TabBarLayout(ImGuiTabBar* tab_bar)+{+ ImGuiContext& g = *GImGui;+ tab_bar->WantLayout = false;++ // Track selected tab when resizing our parent down+ const bool scroll_to_selected_tab = (tab_bar->BarRectPrevWidth > tab_bar->BarRect.GetWidth());+ tab_bar->BarRectPrevWidth = tab_bar->BarRect.GetWidth();++ // Garbage collect by compacting list+ // Detect if we need to sort out tab list (e.g. in rare case where a tab changed section)+ int tab_dst_n = 0;+ bool need_sort_by_section = false;+ ImGuiTabBarSection sections[3]; // Layout sections: Leading, Central, Trailing+ for (int tab_src_n = 0; tab_src_n < tab_bar->Tabs.Size; tab_src_n++)+ {+ ImGuiTabItem* tab = &tab_bar->Tabs[tab_src_n];+ if (tab->LastFrameVisible < tab_bar->PrevFrameVisible || tab->WantClose)+ {+ // Remove tab+ if (tab_bar->VisibleTabContentsId == tab->ID) { tab_bar->VisibleTabContentsId = 0; }+ if (tab_bar->SelectedTabId == tab->ID) { tab_bar->SelectedTabId = 0; }+ if (tab_bar->NextSelectedTabId == tab->ID) { tab_bar->NextSelectedTabId = 0; }+ continue;+ }+ if (tab_dst_n != tab_src_n)+ tab_bar->Tabs[tab_dst_n] = tab_bar->Tabs[tab_src_n];++ tab = &tab_bar->Tabs[tab_dst_n];+ tab->IndexDuringLayout = (ImS16)tab_dst_n;++ // We will need sorting if tabs have changed section (e.g. moved from one of Leading/Central/Trailing to another)+ int curr_tab_section_n = TabItemGetSectionIdx(tab);+ if (tab_dst_n > 0)+ {+ ImGuiTabItem* prev_tab = &tab_bar->Tabs[tab_dst_n - 1];+ int prev_tab_section_n = TabItemGetSectionIdx(prev_tab);+ if (curr_tab_section_n == 0 && prev_tab_section_n != 0)+ need_sort_by_section = true;+ if (prev_tab_section_n == 2 && curr_tab_section_n != 2)+ need_sort_by_section = true;+ }++ sections[curr_tab_section_n].TabCount++;+ tab_dst_n++;+ }+ if (tab_bar->Tabs.Size != tab_dst_n)+ tab_bar->Tabs.resize(tab_dst_n);++ if (need_sort_by_section)+ ImQsort(tab_bar->Tabs.Data, tab_bar->Tabs.Size, sizeof(ImGuiTabItem), TabItemComparerBySection);++ // Calculate spacing between sections+ const float tab_spacing = g.Style.ItemInnerSpacing.x;+ sections[0].Spacing = sections[0].TabCount > 0 && (sections[1].TabCount + sections[2].TabCount) > 0 ? tab_spacing : 0.0f;+ sections[1].Spacing = sections[1].TabCount > 0 && sections[2].TabCount > 0 ? tab_spacing : 0.0f;++ // Setup next selected tab+ ImGuiID scroll_to_tab_id = 0;+ if (tab_bar->NextScrollToTabId)+ {+ scroll_to_tab_id = tab_bar->NextScrollToTabId;+ tab_bar->NextScrollToTabId = 0;+ }+ if (tab_bar->NextSelectedTabId)+ {+ tab_bar->SelectedTabId = tab_bar->NextSelectedTabId;+ tab_bar->NextSelectedTabId = 0;+ scroll_to_tab_id = tab_bar->SelectedTabId;+ }++ // Process order change request (we could probably process it when requested but it's just saner to do it in a single spot).+ if (tab_bar->ReorderRequestTabId != 0)+ {+ if (TabBarProcessReorder(tab_bar))+ if (tab_bar->ReorderRequestTabId == tab_bar->SelectedTabId)+ scroll_to_tab_id = tab_bar->ReorderRequestTabId;+ tab_bar->ReorderRequestTabId = 0;+ }++ // Tab List Popup (will alter tab_bar->BarRect and therefore the available width!)+ const bool tab_list_popup_button = (tab_bar->Flags & ImGuiTabBarFlags_TabListPopupButton) != 0;+ if (tab_list_popup_button)+ if (ImGuiTabItem* tab_to_select = TabBarTabListPopupButton(tab_bar)) // NB: Will alter BarRect.Min.x!+ scroll_to_tab_id = tab_bar->SelectedTabId = tab_to_select->ID;++ // Leading/Trailing tabs will be shrink only if central one aren't visible anymore, so layout the shrink data as: leading, trailing, central+ // (whereas our tabs are stored as: leading, central, trailing)+ int shrink_buffer_indexes[3] = { 0, sections[0].TabCount + sections[2].TabCount, sections[0].TabCount };+ g.ShrinkWidthBuffer.resize(tab_bar->Tabs.Size);++ // Minimum shrink width+ const float shrink_min_width = (tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyMixed) ? g.Style.TabMinWidthShrink : 1.0f;++ // Compute ideal tabs widths + store them into shrink buffer+ ImGuiTabItem* most_recently_selected_tab = NULL;+ int curr_section_n = -1;+ bool found_selected_tab_id = false;+ for (int tab_n = 0; tab_n < tab_bar->Tabs.Size; tab_n++)+ {+ ImGuiTabItem* tab = &tab_bar->Tabs[tab_n];+ IM_ASSERT(tab->LastFrameVisible >= tab_bar->PrevFrameVisible);++ if ((most_recently_selected_tab == NULL || most_recently_selected_tab->LastFrameSelected < tab->LastFrameSelected) && !(tab->Flags & ImGuiTabItemFlags_Button))+ most_recently_selected_tab = tab;+ if (tab->ID == tab_bar->SelectedTabId)+ found_selected_tab_id = true;+ if (scroll_to_tab_id == 0 && g.NavJustMovedToId == tab->ID)+ scroll_to_tab_id = tab->ID;++ // Refresh tab width immediately, otherwise changes of style e.g. style.FramePadding.x would noticeably lag in the tab bar.+ // Additionally, when using TabBarAddTab() to manipulate tab bar order we occasionally insert new tabs that don't have a width yet,+ // and we cannot wait for the next BeginTabItem() call. We cannot compute this width within TabBarAddTab() because font size depends on the active window.+ const char* tab_name = TabBarGetTabName(tab_bar, tab);+ const bool has_close_button_or_unsaved_marker = (tab->Flags & ImGuiTabItemFlags_NoCloseButton) == 0 || (tab->Flags & ImGuiTabItemFlags_UnsavedDocument);+ tab->ContentWidth = (tab->RequestedWidth >= 0.0f) ? tab->RequestedWidth : TabItemCalcSize(tab_name, has_close_button_or_unsaved_marker).x;+ if ((tab->Flags & ImGuiTabItemFlags_Button) == 0)+ tab->ContentWidth = ImMax(tab->ContentWidth, g.Style.TabMinWidthBase);++ int section_n = TabItemGetSectionIdx(tab);+ ImGuiTabBarSection* section = §ions[section_n];+ section->Width += tab->ContentWidth + (section_n == curr_section_n ? tab_spacing : 0.0f);+ section->WidthAfterShrinkMinWidth += ImMin(tab->ContentWidth, shrink_min_width) + (section_n == curr_section_n ? tab_spacing : 0.0f);+ curr_section_n = section_n;++ // Store data so we can build an array sorted by width if we need to shrink tabs down+ IM_MSVC_WARNING_SUPPRESS(6385);+ ImGuiShrinkWidthItem* shrink_width_item = &g.ShrinkWidthBuffer[shrink_buffer_indexes[section_n]++];+ shrink_width_item->Index = tab_n;+ shrink_width_item->Width = shrink_width_item->InitialWidth = tab->ContentWidth;+ tab->Width = ImMax(tab->ContentWidth, 1.0f);+ }++ // Compute total ideal width (used for e.g. auto-resizing a window)+ float width_all_tabs_after_min_width_shrink = 0.0f;+ tab_bar->WidthAllTabsIdeal = 0.0f;+ for (int section_n = 0; section_n < 3; section_n++)+ {+ tab_bar->WidthAllTabsIdeal += sections[section_n].Width + sections[section_n].Spacing;+ width_all_tabs_after_min_width_shrink += sections[section_n].WidthAfterShrinkMinWidth + sections[section_n].Spacing;+ }++ // Horizontal scrolling buttons+ // - Important: note that TabBarScrollButtons() will alter BarRect.Max.x.+ // - Selection skips buttons and might cross through sections if there are Tabs in Leading/Trailing sections.+ const bool can_scroll = (tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyScroll) || (tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyMixed);+ const float width_all_tabs_to_use_for_scroll = (tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyScroll) ? tab_bar->WidthAllTabs : width_all_tabs_after_min_width_shrink;+ tab_bar->ScrollButtonEnabled = ((width_all_tabs_to_use_for_scroll > tab_bar->BarRect.GetWidth() && tab_bar->Tabs.Size > 1) && !(tab_bar->Flags & ImGuiTabBarFlags_NoTabListScrollingButtons) && can_scroll);+ if (tab_bar->ScrollButtonEnabled)+ if (ImGuiTabItem* scroll_and_select_tab = TabBarScrollingButtons(tab_bar))+ {+ if ((scroll_and_select_tab->Flags & ImGuiTabItemFlags_Button) == 0)+ tab_bar->SelectedTabId = scroll_and_select_tab->ID;+ scroll_to_tab_id = scroll_and_select_tab->ID;+ }+ if (scroll_to_tab_id == 0 && scroll_to_selected_tab)+ scroll_to_tab_id = tab_bar->SelectedTabId;++ // Shrink widths if full tabs don't fit in their allocated space+ float section_0_w = sections[0].Width + sections[0].Spacing;+ float section_1_w = sections[1].Width + sections[1].Spacing;+ float section_2_w = sections[2].Width + sections[2].Spacing;+ bool central_section_is_visible = (section_0_w + section_2_w) < tab_bar->BarRect.GetWidth();+ float width_excess;+ if (central_section_is_visible)+ width_excess = ImMax(section_1_w - (tab_bar->BarRect.GetWidth() - section_0_w - section_2_w), 0.0f); // Excess used to shrink central section+ else+ width_excess = (section_0_w + section_2_w) - tab_bar->BarRect.GetWidth(); // Excess used to shrink leading/trailing section++ // With ImGuiTabBarFlags_FittingPolicyScroll policy, we will only shrink leading/trailing if the central section is not visible anymore+ const bool can_shrink = (tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyShrink) || (tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyMixed);+ if (width_excess >= 1.0f && (can_shrink || !central_section_is_visible))+ {+ int shrink_data_count = (central_section_is_visible ? sections[1].TabCount : sections[0].TabCount + sections[2].TabCount);+ int shrink_data_offset = (central_section_is_visible ? sections[0].TabCount + sections[2].TabCount : 0);+ ShrinkWidths(g.ShrinkWidthBuffer.Data + shrink_data_offset, shrink_data_count, width_excess, shrink_min_width);++ // Apply shrunk values into tabs and sections+ for (int tab_n = shrink_data_offset; tab_n < shrink_data_offset + shrink_data_count; tab_n++)+ {+ ImGuiTabItem* tab = &tab_bar->Tabs[g.ShrinkWidthBuffer[tab_n].Index];+ float shrinked_width = IM_TRUNC(g.ShrinkWidthBuffer[tab_n].Width);+ if (shrinked_width < 0.0f)+ continue;++ shrinked_width = ImMax(1.0f, shrinked_width);+ int section_n = TabItemGetSectionIdx(tab);+ sections[section_n].Width -= (tab->Width - shrinked_width);+ tab->Width = shrinked_width;+ }+ }++ // Layout all active tabs+ int section_tab_index = 0;+ float tab_offset = 0.0f;+ tab_bar->WidthAllTabs = 0.0f;+ for (int section_n = 0; section_n < 3; section_n++)+ {+ ImGuiTabBarSection* section = §ions[section_n];+ if (section_n == 2)+ tab_offset = ImMin(ImMax(0.0f, tab_bar->BarRect.GetWidth() - section->Width), tab_offset);++ for (int tab_n = 0; tab_n < section->TabCount; tab_n++)+ {+ ImGuiTabItem* tab = &tab_bar->Tabs[section_tab_index + tab_n];+ tab->Offset = tab_offset;+ tab->NameOffset = -1;+ tab_offset += tab->Width + (tab_n < section->TabCount - 1 ? g.Style.ItemInnerSpacing.x : 0.0f);+ }+ tab_bar->WidthAllTabs += ImMax(section->Width + section->Spacing, 0.0f);+ tab_offset += section->Spacing;+ section_tab_index += section->TabCount;+ }++ // Clear name buffers+ tab_bar->TabsNames.Buf.resize(0);++ // If we have lost the selected tab, select the next most recently active one+ const bool tab_bar_appearing = (tab_bar->PrevFrameVisible + 1 < g.FrameCount);+ if (found_selected_tab_id == false && !tab_bar_appearing)+ tab_bar->SelectedTabId = 0;+ if (tab_bar->SelectedTabId == 0 && tab_bar->NextSelectedTabId == 0 && most_recently_selected_tab != NULL)+ scroll_to_tab_id = tab_bar->SelectedTabId = most_recently_selected_tab->ID;++ // Lock in visible tab+ tab_bar->VisibleTabContentsId = tab_bar->SelectedTabId;+ tab_bar->VisibleTabWasSubmitted = tab_bar->LastTabItemContentsAppearing = false;++ // Apply request requests+ if (scroll_to_tab_id != 0)+ TabBarScrollToTab(tab_bar, scroll_to_tab_id, sections);+ else if (tab_bar->ScrollButtonEnabled && IsMouseHoveringRect(tab_bar->BarRect.Min, tab_bar->BarRect.Max, true) && IsWindowContentHoverable(g.CurrentWindow))+ {+ const float wheel = g.IO.MouseWheelRequestAxisSwap ? g.IO.MouseWheel : g.IO.MouseWheelH;+ const ImGuiKey wheel_key = g.IO.MouseWheelRequestAxisSwap ? ImGuiKey_MouseWheelY : ImGuiKey_MouseWheelX;+ if (TestKeyOwner(wheel_key, tab_bar->ID) && wheel != 0.0f)+ {+ const float scroll_step = wheel * TabBarCalcScrollableWidth(tab_bar, sections) / 3.0f;+ tab_bar->ScrollingTargetDistToVisibility = 0.0f;+ tab_bar->ScrollingTarget = TabBarScrollClamp(tab_bar, tab_bar->ScrollingTarget - scroll_step);+ }+ SetKeyOwner(wheel_key, tab_bar->ID);+ }++ // Update scrolling+ tab_bar->ScrollingAnim = TabBarScrollClamp(tab_bar, tab_bar->ScrollingAnim);+ tab_bar->ScrollingTarget = TabBarScrollClamp(tab_bar, tab_bar->ScrollingTarget);+ if (tab_bar->ScrollingAnim != tab_bar->ScrollingTarget)+ {+ // Scrolling speed adjust itself so we can always reach our target in 1/3 seconds.+ // Teleport if we are aiming far off the visible line+ tab_bar->ScrollingSpeed = ImMax(tab_bar->ScrollingSpeed, 70.0f * g.FontSize);+ tab_bar->ScrollingSpeed = ImMax(tab_bar->ScrollingSpeed, ImFabs(tab_bar->ScrollingTarget - tab_bar->ScrollingAnim) / 0.3f);+ const bool teleport = (tab_bar->PrevFrameVisible + 1 < g.FrameCount) || (tab_bar->ScrollingTargetDistToVisibility > 10.0f * g.FontSize);+ tab_bar->ScrollingAnim = teleport ? tab_bar->ScrollingTarget : ImLinearSweep(tab_bar->ScrollingAnim, tab_bar->ScrollingTarget, g.IO.DeltaTime * tab_bar->ScrollingSpeed);+ }+ else+ {+ tab_bar->ScrollingSpeed = 0.0f;+ }+ tab_bar->ScrollingRectMinX = tab_bar->BarRect.Min.x + sections[0].Width + sections[0].Spacing;+ tab_bar->ScrollingRectMaxX = tab_bar->BarRect.Max.x - sections[2].Width - sections[1].Spacing;++ // Actual layout in host window (we don't do it in BeginTabBar() so as not to waste an extra frame)+ ImGuiWindow* window = g.CurrentWindow;+ window->DC.CursorPos = tab_bar->BarRect.Min;+ ItemSize(ImVec2(tab_bar->WidthAllTabs, tab_bar->BarRect.GetHeight()), tab_bar->FramePadding.y);+ window->DC.IdealMaxPos.x = ImMax(window->DC.IdealMaxPos.x, tab_bar->BarRect.Min.x + tab_bar->WidthAllTabsIdeal);+}++// Dockable windows uses Name/ID in the global namespace. Non-dockable items use the ID stack.+static ImU32 ImGui::TabBarCalcTabID(ImGuiTabBar* tab_bar, const char* label, ImGuiWindow* docked_window)+{+ IM_ASSERT(docked_window == NULL); // master branch only+ IM_UNUSED(docked_window);+ if (tab_bar->Flags & ImGuiTabBarFlags_DockNode)+ {+ ImGuiID id = ImHashStr(label);+ KeepAliveID(id);+ return id;+ }+ else+ {+ ImGuiWindow* window = GImGui->CurrentWindow;+ return window->GetID(label);+ }+}++static float ImGui::TabBarCalcMaxTabWidth()+{+ ImGuiContext& g = *GImGui;+ return g.FontSize * 20.0f;+}++ImGuiTabItem* ImGui::TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id)+{+ if (tab_id != 0)+ for (int n = 0; n < tab_bar->Tabs.Size; n++)+ if (tab_bar->Tabs[n].ID == tab_id)+ return &tab_bar->Tabs[n];+ return NULL;+}++// Order = visible order, not submission order! (which is tab->BeginOrder)+ImGuiTabItem* ImGui::TabBarFindTabByOrder(ImGuiTabBar* tab_bar, int order)+{+ if (order < 0 || order >= tab_bar->Tabs.Size)+ return NULL;+ return &tab_bar->Tabs[order];+}++ImGuiTabItem* ImGui::TabBarGetCurrentTab(ImGuiTabBar* tab_bar)+{+ if (tab_bar->LastTabItemIdx < 0 || tab_bar->LastTabItemIdx >= tab_bar->Tabs.Size)+ return NULL;+ return &tab_bar->Tabs[tab_bar->LastTabItemIdx];+}++const char* ImGui::TabBarGetTabName(ImGuiTabBar* tab_bar, ImGuiTabItem* tab)+{+ if (tab->NameOffset == -1)+ return "N/A";+ IM_ASSERT(tab->NameOffset < tab_bar->TabsNames.Buf.Size);+ return tab_bar->TabsNames.Buf.Data + tab->NameOffset;+}++ImVec2 ImGui::TabBarGetTabPos(ImGuiTabBar* tab_bar, ImGuiTabItem* tab)+{+ if ((tab->Flags & ImGuiTabItemFlags_SectionMask_) == 0)+ return tab_bar->BarRect.Min + ImVec2(IM_TRUNC(tab->Offset - tab_bar->ScrollingAnim), 0.0f);+ else+ return tab_bar->BarRect.Min + ImVec2(tab->Offset, 0.0f);+}++// The *TabId fields are already set by the docking system _before_ the actual TabItem was created, so we clear them regardless.+void ImGui::TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id)+{+ if (ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id))+ tab_bar->Tabs.erase(tab);+ if (tab_bar->VisibleTabContentsId == tab_id){ tab_bar->VisibleTabContentsId = 0; }+ if (tab_bar->SelectedTabId == tab_id) { tab_bar->SelectedTabId = 0; }+ if (tab_bar->NextSelectedTabId == tab_id) { tab_bar->NextSelectedTabId = 0; }+}++// Called on manual closure attempt+void ImGui::TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab)+{+ if (tab->Flags & ImGuiTabItemFlags_Button)+ return; // A button appended with TabItemButton().++ if ((tab->Flags & (ImGuiTabItemFlags_UnsavedDocument | ImGuiTabItemFlags_NoAssumedClosure)) == 0)+ {+ // This will remove a frame of lag for selecting another tab on closure.+ // However we don't run it in the case where the 'Unsaved' flag is set, so user gets a chance to fully undo the closure+ tab->WantClose = true;+ if (tab_bar->VisibleTabContentsId == tab->ID)+ {+ tab->LastFrameVisible = -1;+ tab_bar->SelectedTabId = tab_bar->NextSelectedTabId = 0;+ }+ }+ else+ {+ // Actually select before expecting closure attempt (on an UnsavedDocument tab user is expect to e.g. show a popup)+ if (tab_bar->VisibleTabContentsId != tab->ID)+ TabBarQueueFocus(tab_bar, tab);+ }+}++static float ImGui::TabBarScrollClamp(ImGuiTabBar* tab_bar, float scrolling)+{+ scrolling = ImMin(scrolling, tab_bar->WidthAllTabs - tab_bar->BarRect.GetWidth());+ return ImMax(scrolling, 0.0f);+}++// Note: we may scroll to tab that are not selected! e.g. using keyboard arrow keys+static void ImGui::TabBarScrollToTab(ImGuiTabBar* tab_bar, ImGuiID tab_id, ImGuiTabBarSection* sections)+{+ ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id);+ if (tab == NULL)+ return;++ // Clamp attempt to scroll to leading/trailing sections items.+ // This could be done at the TabBarScrollingButtons() call site as well, but here works.+ if (tab->Flags & ImGuiTabItemFlags_Leading)+ tab = &tab_bar->Tabs[sections[0].TabCount];+ else if (tab->Flags & ImGuiTabItemFlags_Trailing)+ tab = &tab_bar->Tabs[sections[0].TabCount + sections[1].TabCount];+ if (tab->Flags & ImGuiTabItemFlags_SectionMask_)+ return;++ // When scrolling to make Tab N+1 visible always make a bit of N visible to suggest more scrolling area (since we don't have a scrollbar)+ // Disable the margin if the scrolling section is too small for the target tab: prefer displaying a maximum of the label.+ ImGuiContext& g = *GImGui;+ float margin = ImClamp(tab_bar->ScrollingRectMaxX - tab_bar->ScrollingRectMinX - tab->Width, g.Style.ItemInnerSpacing.x, g.FontSize * 1.0f);+ int order = TabBarGetTabOrder(tab_bar, tab);++ // Scrolling happens only in the central section (leading/trailing sections are not scrolling)+ float scrollable_width = TabBarCalcScrollableWidth(tab_bar, sections);++ // We make all tabs positions all relative Sections[0].Width to make code simpler+ float tab_x1 = tab->Offset - sections[0].Width + (order > sections[0].TabCount - 1 ? -margin : 0.0f);+ float tab_x2 = tab->Offset - sections[0].Width + tab->Width + (order + 1 < tab_bar->Tabs.Size - sections[2].TabCount ? margin : 1.0f);+ tab_bar->ScrollingTargetDistToVisibility = 0.0f;+ if (tab_bar->ScrollingTarget > tab_x1 || (tab_x2 - tab_x1 >= scrollable_width))+ {+ // Scroll to the left+ tab_bar->ScrollingTargetDistToVisibility = ImMax(tab_bar->ScrollingAnim - tab_x2, 0.0f);+ tab_bar->ScrollingTarget = tab_x1;+ }+ else if (tab_bar->ScrollingTarget < tab_x2 - scrollable_width)+ {+ // Scroll to the right+ tab_bar->ScrollingTargetDistToVisibility = ImMax((tab_x1 - scrollable_width) - tab_bar->ScrollingAnim, 0.0f);+ tab_bar->ScrollingTarget = tab_x2 - scrollable_width;+ }+}++void ImGui::TabBarQueueFocus(ImGuiTabBar* tab_bar, ImGuiTabItem* tab)+{+ tab_bar->NextSelectedTabId = tab->ID;+}++void ImGui::TabBarQueueFocus(ImGuiTabBar* tab_bar, const char* tab_name)+{+ IM_ASSERT((tab_bar->Flags & ImGuiTabBarFlags_DockNode) == 0); // Only supported for manual/explicit tab bars+ ImGuiID tab_id = TabBarCalcTabID(tab_bar, tab_name, NULL);+ tab_bar->NextSelectedTabId = tab_id;+}++void ImGui::TabBarQueueReorder(ImGuiTabBar* tab_bar, ImGuiTabItem* tab, int offset)+{+ IM_ASSERT(offset != 0);+ IM_ASSERT(tab_bar->ReorderRequestTabId == 0);+ tab_bar->ReorderRequestTabId = tab->ID;+ tab_bar->ReorderRequestOffset = (ImS16)offset;+}++void ImGui::TabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar, ImGuiTabItem* src_tab, ImVec2 mouse_pos)+{+ ImGuiContext& g = *GImGui;+ IM_ASSERT(tab_bar->ReorderRequestTabId == 0);+ if ((tab_bar->Flags & ImGuiTabBarFlags_Reorderable) == 0)+ return;++ const float tab_spacing = g.Style.ItemInnerSpacing.x;+ const bool is_central_section = (src_tab->Flags & ImGuiTabItemFlags_SectionMask_) == 0;+ const float bar_offset = tab_bar->BarRect.Min.x - (is_central_section ? tab_bar->ScrollingTarget : 0);++ // Count number of contiguous tabs we are crossing over+ const int dir = (bar_offset + src_tab->Offset) > mouse_pos.x ? -1 : +1;+ const int src_idx = tab_bar->Tabs.index_from_ptr(src_tab);+ int dst_idx = src_idx;+ for (int i = src_idx; i >= 0 && i < tab_bar->Tabs.Size; i += dir)+ {+ // Reordered tabs must share the same section+ const ImGuiTabItem* dst_tab = &tab_bar->Tabs[i];+ if (dst_tab->Flags & ImGuiTabItemFlags_NoReorder)+ break;+ if ((dst_tab->Flags & ImGuiTabItemFlags_SectionMask_) != (src_tab->Flags & ImGuiTabItemFlags_SectionMask_))+ break;+ dst_idx = i;++ // Include spacing after tab, so when mouse cursor is between tabs we would not continue checking further tabs that are not hovered.+ const float x1 = bar_offset + dst_tab->Offset - tab_spacing;+ const float x2 = bar_offset + dst_tab->Offset + dst_tab->Width + tab_spacing;+ //GetForegroundDrawList()->AddRect(ImVec2(x1, tab_bar->BarRect.Min.y), ImVec2(x2, tab_bar->BarRect.Max.y), IM_COL32(255, 0, 0, 255));+ if ((dir < 0 && mouse_pos.x > x1) || (dir > 0 && mouse_pos.x < x2))+ break;+ }++ if (dst_idx != src_idx)+ TabBarQueueReorder(tab_bar, src_tab, dst_idx - src_idx);+}++bool ImGui::TabBarProcessReorder(ImGuiTabBar* tab_bar)+{+ ImGuiTabItem* tab1 = TabBarFindTabByID(tab_bar, tab_bar->ReorderRequestTabId);+ if (tab1 == NULL || (tab1->Flags & ImGuiTabItemFlags_NoReorder))+ return false;++ //IM_ASSERT(tab_bar->Flags & ImGuiTabBarFlags_Reorderable); // <- this may happen when using debug tools+ int tab2_order = TabBarGetTabOrder(tab_bar, tab1) + tab_bar->ReorderRequestOffset;+ if (tab2_order < 0 || tab2_order >= tab_bar->Tabs.Size)+ return false;++ // Reordered tabs must share the same section+ // (Note: TabBarQueueReorderFromMousePos() also has a similar test but since we allow direct calls to TabBarQueueReorder() we do it here too)+ ImGuiTabItem* tab2 = &tab_bar->Tabs[tab2_order];+ if (tab2->Flags & ImGuiTabItemFlags_NoReorder)+ return false;+ if ((tab1->Flags & ImGuiTabItemFlags_SectionMask_) != (tab2->Flags & ImGuiTabItemFlags_SectionMask_))+ return false;++ ImGuiTabItem item_tmp = *tab1;+ ImGuiTabItem* src_tab = (tab_bar->ReorderRequestOffset > 0) ? tab1 + 1 : tab2;+ ImGuiTabItem* dst_tab = (tab_bar->ReorderRequestOffset > 0) ? tab1 : tab2 + 1;+ const int move_count = (tab_bar->ReorderRequestOffset > 0) ? tab_bar->ReorderRequestOffset : -tab_bar->ReorderRequestOffset;+ memmove(dst_tab, src_tab, move_count * sizeof(ImGuiTabItem));+ *tab2 = item_tmp;++ if (tab_bar->Flags & ImGuiTabBarFlags_SaveSettings)+ MarkIniSettingsDirty();+ return true;+}++static ImGuiTabItem* ImGui::TabBarScrollingButtons(ImGuiTabBar* tab_bar)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ const ImVec2 arrow_button_size(g.FontSize - 2.0f, g.FontSize + g.Style.FramePadding.y * 2.0f);+ const float scrolling_buttons_width = arrow_button_size.x * 2.0f;++ const ImVec2 backup_cursor_pos = window->DC.CursorPos;+ //window->DrawList->AddRect(ImVec2(tab_bar->BarRect.Max.x - scrolling_buttons_width, tab_bar->BarRect.Min.y), ImVec2(tab_bar->BarRect.Max.x, tab_bar->BarRect.Max.y), IM_COL32(255,0,0,255));++ int select_dir = 0;+ ImVec4 arrow_col = g.Style.Colors[ImGuiCol_Text];+ arrow_col.w *= 0.5f;++ PushStyleColor(ImGuiCol_Text, arrow_col);+ PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));+ PushItemFlag(ImGuiItemFlags_ButtonRepeat | ImGuiItemFlags_NoNav, true);+ const float backup_repeat_delay = g.IO.KeyRepeatDelay;+ const float backup_repeat_rate = g.IO.KeyRepeatRate;+ g.IO.KeyRepeatDelay = 0.250f;+ g.IO.KeyRepeatRate = 0.200f;+ float x = ImMax(tab_bar->BarRect.Min.x, tab_bar->BarRect.Max.x - scrolling_buttons_width);+ window->DC.CursorPos = ImVec2(x, tab_bar->BarRect.Min.y);+ if (ArrowButtonEx("##<", ImGuiDir_Left, arrow_button_size, ImGuiButtonFlags_PressedOnClick))+ select_dir = -1;+ window->DC.CursorPos = ImVec2(x + arrow_button_size.x, tab_bar->BarRect.Min.y);+ if (ArrowButtonEx("##>", ImGuiDir_Right, arrow_button_size, ImGuiButtonFlags_PressedOnClick))+ select_dir = +1;+ PopItemFlag();+ PopStyleColor(2);+ g.IO.KeyRepeatRate = backup_repeat_rate;+ g.IO.KeyRepeatDelay = backup_repeat_delay;++ ImGuiTabItem* tab_to_scroll_to = NULL;+ if (select_dir != 0)+ if (ImGuiTabItem* tab_item = TabBarFindTabByID(tab_bar, tab_bar->SelectedTabId))+ {+ int selected_order = TabBarGetTabOrder(tab_bar, tab_item);+ int target_order = selected_order + select_dir;++ // Skip tab item buttons until another tab item is found or end is reached+ while (tab_to_scroll_to == NULL)+ {+ // If we are at the end of the list, still scroll to make our tab visible+ tab_to_scroll_to = &tab_bar->Tabs[(target_order >= 0 && target_order < tab_bar->Tabs.Size) ? target_order : selected_order];++ // Cross through buttons+ // (even if first/last item is a button, return it so we can update the scroll)+ if (tab_to_scroll_to->Flags & ImGuiTabItemFlags_Button)+ {+ target_order += select_dir;+ selected_order += select_dir;+ tab_to_scroll_to = (target_order < 0 || target_order >= tab_bar->Tabs.Size) ? tab_to_scroll_to : NULL;+ }+ }+ }+ window->DC.CursorPos = backup_cursor_pos;+ tab_bar->BarRect.Max.x -= scrolling_buttons_width + 1.0f;++ return tab_to_scroll_to;+}++static ImGuiTabItem* ImGui::TabBarTabListPopupButton(ImGuiTabBar* tab_bar)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;++ // We use g.Style.FramePadding.y to match the square ArrowButton size+ const float tab_list_popup_button_width = g.FontSize + g.Style.FramePadding.y;+ const ImVec2 backup_cursor_pos = window->DC.CursorPos;+ window->DC.CursorPos = ImVec2(tab_bar->BarRect.Min.x - g.Style.FramePadding.y, tab_bar->BarRect.Min.y);+ tab_bar->BarRect.Min.x += tab_list_popup_button_width;++ ImVec4 arrow_col = g.Style.Colors[ImGuiCol_Text];+ arrow_col.w *= 0.5f;+ PushStyleColor(ImGuiCol_Text, arrow_col);+ PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));+ bool open = BeginCombo("##v", NULL, ImGuiComboFlags_NoPreview | ImGuiComboFlags_HeightLargest);+ PopStyleColor(2);++ ImGuiTabItem* tab_to_select = NULL;+ if (open)+ {+ for (int tab_n = 0; tab_n < tab_bar->Tabs.Size; tab_n++)+ {+ ImGuiTabItem* tab = &tab_bar->Tabs[tab_n];+ if (tab->Flags & ImGuiTabItemFlags_Button)+ continue;++ const char* tab_name = TabBarGetTabName(tab_bar, tab);+ if (Selectable(tab_name, tab_bar->SelectedTabId == tab->ID))+ tab_to_select = tab;+ }+ EndCombo();+ }++ window->DC.CursorPos = backup_cursor_pos;+ return tab_to_select;+}++//-------------------------------------------------------------------------+// [SECTION] Widgets: BeginTabItem, EndTabItem, etc.+//-------------------------------------------------------------------------+// - BeginTabItem()+// - EndTabItem()+// - TabItemButton()+// - TabItemEx() [Internal]+// - SetTabItemClosed()+// - TabItemCalcSize() [Internal]+// - TabItemBackground() [Internal]+// - TabItemLabelAndCloseButton() [Internal]+//-------------------------------------------------------------------------++bool ImGui::BeginTabItem(const char* label, bool* p_open, ImGuiTabItemFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return false;++ ImGuiTabBar* tab_bar = g.CurrentTabBar;+ IM_ASSERT_USER_ERROR_RETV(tab_bar != NULL, false, "Needs to be called between BeginTabBar() and EndTabBar()!");+ IM_ASSERT((flags & ImGuiTabItemFlags_Button) == 0); // BeginTabItem() Can't be used with button flags, use TabItemButton() instead!++ bool ret = TabItemEx(tab_bar, label, p_open, flags, NULL);+ if (ret && !(flags & ImGuiTabItemFlags_NoPushId))+ {+ ImGuiTabItem* tab = &tab_bar->Tabs[tab_bar->LastTabItemIdx];+ PushOverrideID(tab->ID); // We already hashed 'label' so push into the ID stack directly instead of doing another hash through PushID(label)+ }+ return ret;+}++void ImGui::EndTabItem()+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return;++ ImGuiTabBar* tab_bar = g.CurrentTabBar;+ IM_ASSERT_USER_ERROR_RET(tab_bar != NULL, "Needs to be called between BeginTabBar() and EndTabBar()!");+ IM_ASSERT(tab_bar->LastTabItemIdx >= 0);+ ImGuiTabItem* tab = &tab_bar->Tabs[tab_bar->LastTabItemIdx];+ if (!(tab->Flags & ImGuiTabItemFlags_NoPushId))+ PopID();+}++bool ImGui::TabItemIsContentsAppearing()+{+ ImGuiContext& g = *GImGui;+ return g.CurrentTabBar->LastTabItemContentsAppearing;+}++bool ImGui::TabItemButton(const char* label, ImGuiTabItemFlags flags)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return false;++ ImGuiTabBar* tab_bar = g.CurrentTabBar;+ IM_ASSERT_USER_ERROR_RETV(tab_bar != NULL, false, "Needs to be called between BeginTabBar() and EndTabBar()!");+ return TabItemEx(tab_bar, label, NULL, flags | ImGuiTabItemFlags_Button | ImGuiTabItemFlags_NoReorder, NULL);+}++void ImGui::TabItemSpacing(const char* str_id, ImGuiTabItemFlags flags, float width)+{+ ImGuiContext& g = *GImGui;+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return;++ ImGuiTabBar* tab_bar = g.CurrentTabBar;+ IM_ASSERT_USER_ERROR_RET(tab_bar != NULL, "Needs to be called between BeginTabBar() and EndTabBar()!");+ SetNextItemWidth(width);+ TabItemEx(tab_bar, str_id, NULL, flags | ImGuiTabItemFlags_Button | ImGuiTabItemFlags_NoReorder | ImGuiTabItemFlags_Invisible, NULL);+}++bool ImGui::TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags, ImGuiWindow* docked_window)+{+ // Layout whole tab bar if not already done+ ImGuiContext& g = *GImGui;+ if (tab_bar->WantLayout)+ {+ ImGuiNextItemData backup_next_item_data = g.NextItemData;+ TabBarLayout(tab_bar);+ g.NextItemData = backup_next_item_data;+ }+ ImGuiWindow* window = g.CurrentWindow;+ if (window->SkipItems)+ return false;++ const ImGuiStyle& style = g.Style;+ const ImGuiID id = TabBarCalcTabID(tab_bar, label, docked_window);++ // If the user called us with *p_open == false, we early out and don't render.+ // We make a call to ItemAdd() so that attempts to use a contextual popup menu with an implicit ID won't use an older ID.+ IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);+ if (p_open && !*p_open)+ {+ ItemAdd(ImRect(), id, NULL, ImGuiItemFlags_NoNav);+ return false;+ }++ IM_ASSERT(!p_open || !(flags & ImGuiTabItemFlags_Button));+ IM_ASSERT((flags & (ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing)) != (ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing)); // Can't use both Leading and Trailing++ // Store into ImGuiTabItemFlags_NoCloseButton, also honor ImGuiTabItemFlags_NoCloseButton passed by user (although not documented)+ if (flags & ImGuiTabItemFlags_NoCloseButton)+ p_open = NULL;+ else if (p_open == NULL)+ flags |= ImGuiTabItemFlags_NoCloseButton;++ // Acquire tab data+ ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, id);+ bool tab_is_new = false;+ if (tab == NULL)+ {+ tab_bar->Tabs.push_back(ImGuiTabItem());+ tab = &tab_bar->Tabs.back();+ tab->ID = id;+ tab_bar->TabsAddedNew = tab_is_new = true;+ }+ tab_bar->LastTabItemIdx = (ImS16)tab_bar->Tabs.index_from_ptr(tab);++ // Calculate tab contents size+ ImVec2 size = TabItemCalcSize(label, (p_open != NULL) || (flags & ImGuiTabItemFlags_UnsavedDocument));+ tab->RequestedWidth = -1.0f;+ if (g.NextItemData.HasFlags & ImGuiNextItemDataFlags_HasWidth)+ size.x = tab->RequestedWidth = g.NextItemData.Width;+ if (tab_is_new)+ tab->Width = ImMax(1.0f, size.x);+ tab->ContentWidth = size.x;+ tab->BeginOrder = tab_bar->TabsActiveCount++;++ const bool tab_bar_appearing = (tab_bar->PrevFrameVisible + 1 < g.FrameCount);+ const bool tab_bar_focused = (tab_bar->Flags & ImGuiTabBarFlags_IsFocused) != 0;+ const bool tab_appearing = (tab->LastFrameVisible + 1 < g.FrameCount);+ const bool tab_just_unsaved = (flags & ImGuiTabItemFlags_UnsavedDocument) && !(tab->Flags & ImGuiTabItemFlags_UnsavedDocument);+ const bool is_tab_button = (flags & ImGuiTabItemFlags_Button) != 0;+ tab->LastFrameVisible = g.FrameCount;+ tab->Flags = flags;++ // Append name _WITH_ the zero-terminator+ if (docked_window != NULL)+ {+ IM_ASSERT(docked_window == NULL); // master branch only+ }+ else+ {+ tab->NameOffset = (ImS32)tab_bar->TabsNames.size();+ tab_bar->TabsNames.append(label, label + ImStrlen(label) + 1);+ }++ // Update selected tab+ if (!is_tab_button)+ {+ if (tab_appearing && (tab_bar->Flags & ImGuiTabBarFlags_AutoSelectNewTabs) && tab_bar->NextSelectedTabId == 0)+ if (!tab_bar_appearing || tab_bar->SelectedTabId == 0)+ TabBarQueueFocus(tab_bar, tab); // New tabs gets activated+ if ((flags & ImGuiTabItemFlags_SetSelected) && (tab_bar->SelectedTabId != id)) // _SetSelected can only be passed on explicit tab bar+ TabBarQueueFocus(tab_bar, tab);+ }++ // On the very first frame of a tab bar we let first tab contents be visible to minimize appearing glitches+ if (tab_bar->VisibleTabContentsId == 0 && tab_bar->SelectedTabId == 0 && tab_bar_appearing)+ if (tab_bar->Tabs.Size == 1 && !(tab_bar->Flags & ImGuiTabBarFlags_AutoSelectNewTabs))+ tab_bar->VisibleTabContentsId = id;++ // Lock visibility+ // (Note: tab_contents_visible != tab_selected... because Ctrl+Tab operations may preview some tabs without selecting them!)+ const bool tab_contents_visible = (tab_bar->VisibleTabContentsId == id);+ if (tab_contents_visible)+ tab_bar->VisibleTabWasSubmitted = true;+ tab_bar->LastTabItemContentsAppearing = tab_contents_visible && !tab->ContentsIsVisible;+ tab->ContentsIsVisible = tab_contents_visible;++ // Note that tab_is_new is not necessarily the same as tab_appearing! When a tab bar stops being submitted+ // and then gets submitted again, the tabs will have 'tab_appearing=true' but 'tab_is_new=false'.+ if (tab_appearing && (!tab_bar_appearing || tab_is_new))+ {+ // This path doesn't render the tab.+ ItemAdd(ImRect(), id, NULL, ImGuiItemFlags_NoNav);+ if (is_tab_button)+ return false;+ return tab_contents_visible;+ }++ if (tab_bar->SelectedTabId == id)+ tab->LastFrameSelected = g.FrameCount;++ // Backup current layout position+ const ImVec2 backup_main_cursor_pos = window->DC.CursorPos;++ // Layout+ const bool is_central_section = (tab->Flags & ImGuiTabItemFlags_SectionMask_) == 0;+ size.x = tab->Width;+ window->DC.CursorPos = TabBarGetTabPos(tab_bar, tab);+ ImVec2 pos = window->DC.CursorPos;+ ImRect bb(pos, pos + size);++ // We don't have CPU clipping primitives to clip the CloseButton (until it becomes a texture), so need to add an extra draw call (temporary in the case of vertical animation)+ const bool want_clip_rect = is_central_section && (bb.Min.x < tab_bar->ScrollingRectMinX || bb.Max.x > tab_bar->ScrollingRectMaxX);+ if (want_clip_rect)+ PushClipRect(ImVec2(ImClamp(bb.Min.x, tab_bar->ScrollingRectMinX, tab_bar->ScrollingRectMaxX), bb.Min.y - 1), ImVec2(tab_bar->ScrollingRectMaxX, bb.Max.y), true);++ ImVec2 backup_cursor_max_pos = window->DC.CursorMaxPos;+ ItemSize(bb.GetSize(), style.FramePadding.y);+ window->DC.CursorMaxPos = backup_cursor_max_pos;++ if (!ItemAdd(bb, id))+ {+ if (want_clip_rect)+ PopClipRect();+ window->DC.CursorPos = backup_main_cursor_pos;+ return tab_contents_visible;+ }++ // Click to Select a tab+ // Allow the close button to overlap+ ImGuiButtonFlags button_flags = ((ImGuiButtonFlags)(is_tab_button ? ImGuiButtonFlags_PressedOnClickRelease : ImGuiButtonFlags_PressedOnClick) | ImGuiButtonFlags_AllowOverlap);+ if (g.DragDropActive)+ button_flags |= ImGuiButtonFlags_PressedOnDragDropHold;+ bool hovered, held, pressed;+ if (flags & ImGuiTabItemFlags_Invisible)+ hovered = held = pressed = false;+ else+ pressed = ButtonBehavior(bb, id, &hovered, &held, button_flags);+ if (pressed && !is_tab_button)+ TabBarQueueFocus(tab_bar, tab);++ // Drag and drop: re-order tabs+ if (held && !tab_appearing && IsMouseDragging(0))+ {+ if (!g.DragDropActive && (tab_bar->Flags & ImGuiTabBarFlags_Reorderable))+ {+ // While moving a tab it will jump on the other side of the mouse, so we also test for MouseDelta.x+ if (g.IO.MouseDelta.x < 0.0f && g.IO.MousePos.x < bb.Min.x)+ {+ TabBarQueueReorderFromMousePos(tab_bar, tab, g.IO.MousePos);+ }+ else if (g.IO.MouseDelta.x > 0.0f && g.IO.MousePos.x > bb.Max.x)+ {+ TabBarQueueReorderFromMousePos(tab_bar, tab, g.IO.MousePos);+ }+ }+ }++#if 0+ if (hovered && g.HoveredIdNotActiveTimer > TOOLTIP_DELAY && bb.GetWidth() < tab->ContentWidth)+ {+ // Enlarge tab display when hovering+ bb.Max.x = bb.Min.x + IM_TRUNC(ImLerp(bb.GetWidth(), tab->ContentWidth, ImSaturate((g.HoveredIdNotActiveTimer - 0.40f) * 6.0f)));+ display_draw_list = GetForegroundDrawList(window);+ TabItemBackground(display_draw_list, bb, flags, GetColorU32(ImGuiCol_TitleBgActive));+ }+#endif++ // Render tab shape+ const bool is_visible = (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_Visible) && !(flags & ImGuiTabItemFlags_Invisible);+ if (is_visible)+ {+ ImDrawList* display_draw_list = window->DrawList;+ const ImU32 tab_col = GetColorU32((held || hovered) ? ImGuiCol_TabHovered : tab_contents_visible ? (tab_bar_focused ? ImGuiCol_TabSelected : ImGuiCol_TabDimmedSelected) : (tab_bar_focused ? ImGuiCol_Tab : ImGuiCol_TabDimmed));+ if (BuiOn()) // BUI: Blender tab (tabs_draw: wcol_tab, the current one inner_sel, top corners round)+ {+ BKWidgetDraw w = BuiWidget(BK_WIDGET_TAB, ImRect(bb.Min.x, bb.Min.y + 1.0f, bb.Max.x, bb.Max.y - style.TabBarBorderSize), (held || hovered ? BK_WS_HOVER : 0) | (tab_contents_visible ? BK_WS_SELECTED : 0));+ w.corners = 1 | 2; // CNR_TL | CNR_TR+ BuiEmit(w);+ }+ else // BUI+ TabItemBackground(display_draw_list, bb, flags, tab_col);+ if (tab_contents_visible && (tab_bar->Flags & ImGuiTabBarFlags_DrawSelectedOverline) && style.TabBarOverlineSize > 0.0f)+ {+ // Might be moved to TabItemBackground() ?+ ImVec2 tl = bb.GetTL() + ImVec2(0, style.TabBarOverlineSize * 0.5f);+ ImVec2 tr = bb.GetTR() + ImVec2(0, style.TabBarOverlineSize * 0.5f);+ ImU32 overline_col = GetColorU32(tab_bar_focused ? ImGuiCol_TabSelectedOverline : ImGuiCol_TabDimmedSelectedOverline);+ if (style.TabRounding > 0.0f)+ {+ float rounding = style.TabRounding;+ display_draw_list->PathArcToFast(tl + ImVec2(+rounding, +rounding), rounding, 7, 9);+ display_draw_list->PathArcToFast(tr + ImVec2(-rounding, +rounding), rounding, 9, 11);+ display_draw_list->PathStroke(overline_col, style.TabBarOverlineSize);+ }+ else+ {+ display_draw_list->AddLine(tl, tr, overline_col, style.TabBarOverlineSize);+ }+ }+ RenderNavCursor(bb, id);++ // Select with right mouse button. This is so the common idiom for context menu automatically highlight the current widget.+ const bool hovered_unblocked = IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup);+ if (tab_bar->SelectedTabId != tab->ID && hovered_unblocked && (IsMouseClicked(1) || IsMouseReleased(1)) && !is_tab_button)+ TabBarQueueFocus(tab_bar, tab);++ if (tab_bar->Flags & ImGuiTabBarFlags_NoCloseWithMiddleMouseButton)+ flags |= ImGuiTabItemFlags_NoCloseWithMiddleMouseButton;++ // Render tab label, process close button+ const ImGuiID close_button_id = p_open ? GetIDWithSeed("#CLOSE", NULL, id) : 0;+ bool just_closed;+ bool text_clipped;+ if (BuiOn()) // BUI: wcol_tab text: text_sel on the current tab, text on the others+ PushStyleColor(ImGuiCol_Text, tab_contents_visible ? IM_COL32(0xff, 0xff, 0xff, 0xff) : IM_COL32(0x98, 0x98, 0x98, 0xff));+ TabItemLabelAndCloseButton(display_draw_list, bb, tab_just_unsaved ? (flags & ~ImGuiTabItemFlags_UnsavedDocument) : flags, tab_bar->FramePadding, label, id, close_button_id, tab_contents_visible, &just_closed, &text_clipped);+ if (BuiOn()) // BUI+ PopStyleColor();+ if (just_closed && p_open != NULL)+ {+ *p_open = false;+ TabBarCloseTab(tab_bar, tab);+ }++ // Tooltip+ // (Won't work over the close button because ItemOverlap systems messes up with HoveredIdTimer-> seems ok)+ // (We test IsItemHovered() to discard e.g. when another item is active or drag and drop over the tab bar, which g.HoveredId ignores)+ // FIXME: This is a mess.+ // FIXME: We may want disabled tab to still display the tooltip?+ if (text_clipped && g.HoveredId == id && !held)+ if (!(tab_bar->Flags & ImGuiTabBarFlags_NoTooltip) && !(tab->Flags & ImGuiTabItemFlags_NoTooltip))+ SetItemTooltip("%.*s", (int)(FindRenderedTextEnd(label) - label), label);+ }++ // Restore main window position so user can draw there+ if (want_clip_rect)+ PopClipRect();+ window->DC.CursorPos = backup_main_cursor_pos;++ IM_ASSERT(!is_tab_button || !(tab_bar->SelectedTabId == tab->ID && is_tab_button)); // TabItemButton should not be selected+ if (is_tab_button)+ return pressed;+ return tab_contents_visible;+}++// [Public] This is call is 100% optional but it allows to remove some one-frame glitches when a tab has been unexpectedly removed.+// To use it to need to call the function SetTabItemClosed() between BeginTabBar() and EndTabBar().+// Tabs closed by the close button will automatically be flagged to avoid this issue.+void ImGui::SetTabItemClosed(const char* label)+{+ ImGuiContext& g = *GImGui;+ bool is_within_manual_tab_bar = g.CurrentTabBar && !(g.CurrentTabBar->Flags & ImGuiTabBarFlags_DockNode);+ if (is_within_manual_tab_bar)+ {+ ImGuiTabBar* tab_bar = g.CurrentTabBar;+ ImGuiID tab_id = TabBarCalcTabID(tab_bar, label, NULL);+ if (ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id))+ tab->WantClose = true; // Will be processed by next call to TabBarLayout()+ }+}++ImVec2 ImGui::TabItemCalcSize(const char* label, bool has_close_button_or_unsaved_marker)+{+ ImGuiContext& g = *GImGui;+ ImVec2 label_size = CalcTextSize(label, NULL, true);+ ImVec2 size = ImVec2(label_size.x + g.Style.FramePadding.x, label_size.y + g.Style.FramePadding.y * 2.0f);+ if (has_close_button_or_unsaved_marker)+ size.x += g.Style.FramePadding.x + (g.Style.ItemInnerSpacing.x + g.FontSize); // We use Y intentionally to fit the close button circle.+ else+ size.x += g.Style.FramePadding.x + 1.0f;+ return ImVec2(ImMin(size.x, TabBarCalcMaxTabWidth()), size.y);+}++ImVec2 ImGui::TabItemCalcSize(ImGuiWindow*)+{+ IM_ASSERT(0); // This function exists to facilitate merge with 'docking' branch.+ return ImVec2(0.0f, 0.0f);+}++void ImGui::TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col)+{+ // While rendering tabs, we trim 1 pixel off the top of our bounding box so they can fit within a regular frame height while looking "detached" from it.+ ImGuiContext& g = *GImGui;+ const float width = bb.GetWidth();+ IM_UNUSED(flags);+ IM_ASSERT(width > 0.0f);+ const float rounding = ImMax(0.0f, ImMin((flags & ImGuiTabItemFlags_Button) ? g.Style.FrameRounding : g.Style.TabRounding, width * 0.5f - 1.0f));+ const float y1 = bb.Min.y + 1.0f; // Leave a bit of room in title bars.+ const float y2 = bb.Max.y - g.Style.TabBarBorderSize;+ draw_list->AddRectFilled(ImVec2(bb.Min.x, y1), ImVec2(bb.Max.x, y2), col, rounding, ImDrawFlags_RoundTop);+ if (g.Style.TabBorderSize > 0.0f)+ {+ draw_list->PathLineTo(ImVec2(bb.Min.x, y2));+ draw_list->PathArcToFast(ImVec2(bb.Min.x + rounding, y1 + rounding), rounding, 6, 9);+ draw_list->PathArcToFast(ImVec2(bb.Max.x - rounding, y1 + rounding), rounding, 9, 12);+ draw_list->PathLineTo(ImVec2(bb.Max.x, y2));+ draw_list->PathStroke(GetColorU32(ImGuiCol_Border), g.Style.TabBorderSize, ImDrawFlags_StrokeCenterBiased); // Use _StrokeInside?+ }+}++// Render text label (with custom clipping) + Unsaved Document marker + Close Button logic+// We tend to lock style.FramePadding for a given tab-bar, hence the 'frame_padding' parameter.+void ImGui::TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id, bool is_contents_visible, bool* out_just_closed, bool* out_text_clipped)+{+ ImGuiContext& g = *GImGui;+ const char* label_end = FindRenderedTextEnd(label);+ ImVec2 label_size = CalcTextSize(label, label_end, false);++ if (out_just_closed)+ *out_just_closed = false;+ if (out_text_clipped)+ *out_text_clipped = false;++ if (bb.GetWidth() <= 1.0f)+ return;++ // In Style V2 we'll have full override of all colors per state (e.g. focused, selected)+ // But right now if you want to alter text color of tabs this is what you need to do.+#if 0+ const float backup_alpha = g.Style.Alpha;+ if (!is_contents_visible)+ g.Style.Alpha *= 0.7f;+#endif++ // Render text label (with clipping + alpha gradient) + unsaved marker+ ImRect text_ellipsis_clip_bb(bb.Min.x + frame_padding.x, bb.Min.y + frame_padding.y, bb.Max.x - frame_padding.x, bb.Max.y);++ // Return clipped state ignoring the close button+ if (out_text_clipped)+ {+ *out_text_clipped = (text_ellipsis_clip_bb.Min.x + label_size.x) > text_ellipsis_clip_bb.Max.x;+ //draw_list->AddCircle(text_ellipsis_clip_bb.Min, 3.0f, *out_text_clipped ? IM_COL32(255, 0, 0, 255) : IM_COL32(0, 255, 0, 255));+ }++ const float button_sz = g.FontSize;+ const ImVec2 button_pos(ImMax(bb.Min.x, bb.Max.x - frame_padding.x - button_sz), bb.Min.y + frame_padding.y);++ // Close Button & Unsaved Marker+ // We are relying on a subtle and confusing distinction between 'hovered' and 'g.HoveredId' which happens because we are using ImGuiButtonFlags_AllowOverlapMode + SetItemAllowOverlap()+ // 'hovered' will be true when hovering the Tab but NOT when hovering the close button+ // 'g.HoveredId==id' will be true when hovering the Tab including when hovering the close button+ // 'g.ActiveId==close_button_id' will be true when we are holding on the close button, in which case both hovered booleans are false+ bool close_button_pressed = false;+ bool close_button_visible = false;+ bool is_hovered = g.HoveredId == tab_id || g.HoveredId == close_button_id || g.ActiveId == tab_id || g.ActiveId == close_button_id; // Any interaction account for this too.++ if (close_button_id != 0)+ {+ if (is_contents_visible)+ close_button_visible = (g.Style.TabCloseButtonMinWidthSelected < 0.0f) ? true : (is_hovered && bb.GetWidth() >= ImMax(button_sz, g.Style.TabCloseButtonMinWidthSelected));+ else+ close_button_visible = (g.Style.TabCloseButtonMinWidthUnselected < 0.0f) ? true : (is_hovered && bb.GetWidth() >= ImMax(button_sz, g.Style.TabCloseButtonMinWidthUnselected));+ }++ // When tabs/document is unsaved, the unsaved marker takes priority over the close button.+ const bool unsaved_marker_visible = (flags & ImGuiTabItemFlags_UnsavedDocument) != 0 && (button_pos.x + button_sz <= bb.Max.x) && (!close_button_visible || !is_hovered);+ if (unsaved_marker_visible)+ {+ ImVec2 bullet_pos = button_pos + ImVec2(button_sz, button_sz) * 0.5f;+ RenderBullet(draw_list, bullet_pos, GetColorU32(ImGuiCol_UnsavedMarker));+ }+ else if (close_button_visible)+ {+ ImGuiLastItemData last_item_backup = g.LastItemData;+ if (CloseButton(close_button_id, button_pos))+ close_button_pressed = true;+ g.LastItemData = last_item_backup;++ // Close with middle mouse button+ if (is_hovered && !(flags & ImGuiTabItemFlags_NoCloseWithMiddleMouseButton) && IsMouseClicked(2))+ close_button_pressed = true;+ }++ // This is all rather complicated+ // (the main idea is that because the close button only appears on hover, we don't want it to alter the ellipsis position)+ // FIXME: if FramePadding is noticeably large, ellipsis_max_x will be wrong here (e.g. #3497), maybe for consistency that parameter of RenderTextEllipsis() shouldn't exist..+ float ellipsis_max_x = text_ellipsis_clip_bb.Max.x;+ if (close_button_visible || unsaved_marker_visible)+ {+ const bool visible_without_hover = unsaved_marker_visible || (is_contents_visible ? g.Style.TabCloseButtonMinWidthSelected : g.Style.TabCloseButtonMinWidthUnselected) < 0.0f;+ if (visible_without_hover)+ {+ text_ellipsis_clip_bb.Max.x -= button_sz * 0.90f;+ ellipsis_max_x -= button_sz * 0.90f;+ }+ else+ {+ text_ellipsis_clip_bb.Max.x -= button_sz * 1.00f;+ }+ }+ LogSetNextTextDecoration("/", "\\");+ RenderTextEllipsis(draw_list, text_ellipsis_clip_bb.Min, text_ellipsis_clip_bb.Max, ellipsis_max_x, label, label_end, &label_size);++#if 0+ if (!is_contents_visible)+ g.Style.Alpha = backup_alpha;+#endif++ if (out_just_closed)+ *out_just_closed = close_button_pressed;+}+++#endif // #ifndef IMGUI_DISABLEdiff --git a/bindings/imgui/blender/rebase.py b/bindings/imgui/blender/rebase.pynew file mode 100644index 0000000..664c16f--- /dev/null+++ b/bindings/imgui/blender/rebase.py@@ -0,0 +1,100 @@+#!/usr/bin/env python3+"""Keep blender/imgui_widgets_blender.cpp in step with Dear ImGui's imgui_widgets.cpp.++The copy is upstream's imgui_widgets.cpp plus BUI's edits, every one marked "BUI:". To move it+onto a newer Dear ImGui:++ 1. copy the new upstream files into extern/imgui (as bindings/imgui/README.md says), but do+ not commit yet: git still holds the old imgui_widgets.cpp, the base of the copy;+ 2. py -3 bindings/imgui/blender/rebase.py merge+ a three-way merge (git merge-file): old upstream -> new upstream, applied to the copy.+ Conflicts are left as <<<<<<< markers in the copy; resolve them keeping the BUI: edits;+ 3. py -3 bindings/imgui/blender/rebase.py check+ every changed hunk against the (new) upstream file must mention "BUI";+ 4. build with -DBUI_IMGUI_BLENDER_WIDGETS=ON and run ctest (imgui_backend,+ imgui_c_api, imgui_blender_widgets_match_kit, the Python test).++Other commands:+ rebase.py diff the BUI edits: upstream (extern/imgui) vs the copy, unified diff+ rebase.py merge --base F use file F as the old upstream instead of git's HEAD version++Line endings: the copy keeps upstream's CRLF; comparisons ignore them.+SPDX-License-Identifier: GPL-2.0-or-later+"""++import argparse+import difflib+import os+import subprocess+import sys+import tempfile++HERE = os.path.dirname(os.path.abspath(__file__))+ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))+UPSTREAM = os.path.join(HERE, "..", "extern", "imgui", "imgui_widgets.cpp")+UPSTREAM_GIT = "bindings/imgui/extern/imgui/imgui_widgets.cpp"+COPY = os.path.join(HERE, "imgui_widgets_blender.cpp")+++def read_lines(path):+ with open(path, encoding="utf-8", newline="") as f:+ return [l.rstrip("\r\n") for l in f.read().split("\n")]+++def cmd_diff(_args):+ a, b = read_lines(UPSTREAM), read_lines(COPY)+ sys.stdout.writelines(l + "\n" for l in difflib.unified_diff(a, b, "imgui_widgets.cpp", "imgui_widgets_blender.cpp", n=2, lineterm=""))+ return 0+++def cmd_check(_args):+ a, b = read_lines(UPSTREAM), read_lines(COPY)+ sm = difflib.SequenceMatcher(None, a, b, autojunk=False)+ bad = 0+ hunks = 0+ for tag, i1, i2, j1, j2 in sm.get_opcodes():+ if tag == "equal":+ continue+ hunks += 1+ # the hunk, plus the line before and after it (a "// BUI" may sit on the line above)+ ctx = b[max(0, j1 - 2):min(len(b), j2 + 1)] if j2 > j1 else b[max(0, j1 - 2):min(len(b), j1 + 1)]+ if not any("BUI" in l for l in ctx):+ bad += 1+ print("unmarked change at copy line %d (upstream %d-%d):" % (j1 + 1, i1 + 1, i2))+ for l in a[i1:i2]:+ print(" - " + l)+ for l in b[j1:j2]:+ print(" + " + l)+ print("%d changed hunks, %d without a BUI: mark" % (hunks, bad))+ return 1 if bad else 0+++def cmd_merge(args):+ if args.base:+ base = args.base+ else:+ old = subprocess.run(["git", "-C", ROOT, "show", "HEAD:" + UPSTREAM_GIT], capture_output=True, check=True).stdout+ fd, base = tempfile.mkstemp(suffix="_imgui_widgets_base.cpp")+ with os.fdopen(fd, "wb") as f:+ f.write(old)+ r = subprocess.run(["git", "merge-file", "-L", "imgui_widgets_blender.cpp", "-L", "old upstream", "-L", "new upstream", COPY, base, UPSTREAM])+ if r.returncode == 0:+ print("merged cleanly; now: rebase.py check, build with BUI_IMGUI_BLENDER_WIDGETS=ON, ctest")+ elif r.returncode > 0:+ print("%d conflict(s) left as <<<<<<< markers in %s" % (r.returncode, COPY))+ return 0 if r.returncode == 0 else 1+++def main():+ p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)+ sub = p.add_subparsers(dest="cmd", required=True)+ sub.add_parser("diff")+ sub.add_parser("check")+ m = sub.add_parser("merge")+ m.add_argument("--base", help="the old upstream imgui_widgets.cpp (default: git HEAD's)")+ args = p.parse_args()+ return {"diff": cmd_diff, "check": cmd_check, "merge": cmd_merge}[args.cmd](args)+++if __name__ == "__main__":+ sys.exit(main())diff --git a/bindings/imgui/c/cimgui_impl_bui.cpp b/bindings/imgui/c/cimgui_impl_bui.cppindex 6e9b8f7..c0955e6 100644--- a/bindings/imgui/c/cimgui_impl_bui.cpp+++ b/bindings/imgui/c/cimgui_impl_bui.cpp@@ -77,6 +77,9 @@ CIMGUI_API int cImGui_ImplBUI_FrameCount(void) { return ImGui_ImplBUI_FrameCountCIMGUI_API void cImGui_ImplBUI_StyleBlender(ImGuiStyle* dst, float scale) { ImGui_ImplBUI_StyleBlender(reinterpret_cast<::ImGuiStyle*>(dst), scale); }CIMGUI_API float cImGui_ImplBUI_BlenderFontSize(float scale) { return ImGui_ImplBUI_BlenderFontSize(scale); }+CIMGUI_API bool cImGui_ImplBUI_HasBlenderWidgets(void) { return ImGui_ImplBUI_HasBlenderWidgets(); }+CIMGUI_API void cImGui_ImplBUI_SetBlenderWidgets(bool on) { ImGui_ImplBUI_SetBlenderWidgets(on); }+CIMGUI_API bool cImGui_ImplBUI_GetBlenderWidgets(void) { return ImGui_ImplBUI_GetBlenderWidgets(); }CIMGUI_API ImFont* cImGui_ImplBUI_AddBlenderFont(float size_pixels) { return reinterpret_cast<ImFont*>(ImGui_ImplBUI_AddBlenderFont(size_pixels)); }CIMGUI_API float cImGui_ImplBUI_GetScale(void) { return BK_scale(); }CIMGUI_API void cImGui_ImplBUI_SetScale(float scale) { BK_set_scale(scale); }diff --git a/bindings/imgui/c/cimgui_impl_bui.h b/bindings/imgui/c/cimgui_impl_bui.hindex 6949f40..40ad977 100644--- a/bindings/imgui/c/cimgui_impl_bui.h+++ b/bindings/imgui/c/cimgui_impl_bui.h@@ -55,6 +55,11 @@ CIMGUI_API int cImGui_ImplBUI_FrameCount(void);CIMGUI_API void cImGui_ImplBUI_StyleBlender(ImGuiStyle* dst, float scale);CIMGUI_API float cImGui_ImplBUI_BlenderFontSize(float scale);CIMGUI_API ImFont* cImGui_ImplBUI_AddBlenderFont(float size_pixels);+/* Blender widgets (built with BUI_IMGUI_BLENDER_WIDGETS): ImGui's widgets drawn and handled+ * as Blender's. Has: built with them; Set/Get: the runtime switch (on when built). */+CIMGUI_API bool cImGui_ImplBUI_HasBlenderWidgets(void);+CIMGUI_API void cImGui_ImplBUI_SetBlenderWidgets(bool on);+CIMGUI_API bool cImGui_ImplBUI_GetBlenderWidgets(void);/* BUI's UI scale (DPI): BK_scale() / BK_set_scale(). */CIMGUI_API float cImGui_ImplBUI_GetScale(void);CIMGUI_API void cImGui_ImplBUI_SetScale(float scale);diff --git a/bindings/imgui/imgui_bui_style.cpp b/bindings/imgui/imgui_bui_style.cppindex 8d5eaed..bb7ff71 100644--- a/bindings/imgui/imgui_bui_style.cpp+++ b/bindings/imgui/imgui_bui_style.cpp@@ -132,6 +132,9 @@ void ImGui_ImplBUI_StyleBlender(ImGuiStyle* dst, float scale)style.TreeLinesSize = 1.0f;style.DisabledAlpha = 0.5f; // widget_alpha_factor for disabled buttonsstyle.ScaleAllSizes(scale);+ // Frames exactly one widget unit tall: ImGui rounds the font to whole pixels (13 px at+ // scale 1) and ScaleAllSizes() truncates the padding, which made frames 19 px.+ style.FramePadding.y = ImMax(1.0f, (IM_ROUND(unit * scale) - IM_ROUND(font * scale)) * 0.5f);// -- colors --const ImVec4 text = Rgba(0xe6e6e6ff); // wcol_regular.textdiff --git a/bindings/imgui/imgui_impl_bui.cpp b/bindings/imgui/imgui_impl_bui.cppindex 743c11f..25aef22 100644--- a/bindings/imgui/imgui_impl_bui.cpp+++ b/bindings/imgui/imgui_impl_bui.cpp@@ -77,10 +77,57 @@ struct ContextScope//-----------------------------------------------------------------------------// Markers for the standard draw callbacks: ImGui never calls them, RenderDrawData-// recognizes them.-static void DrawCallback_ResetRenderState(const ImDrawList*, const ImDrawCmd*) {}-static void DrawCallback_SetSamplerLinear(const ImDrawList*, const ImDrawCmd*) {}-static void DrawCallback_SetSamplerNearest(const ImDrawList*, const ImDrawCmd*) {}+// recognizes them by address. Distinct bodies: identical empty functions may be folded into+// one address by the linker (MSVC /OPT:ICF), which would make them indistinguishable.+static volatile int g_MarkerCalls[4];+static void DrawCallback_ResetRenderState(const ImDrawList*, const ImDrawCmd*) { g_MarkerCalls[0] = 1; }+static void DrawCallback_SetSamplerLinear(const ImDrawList*, const ImDrawCmd*) { g_MarkerCalls[1] = 2; }+static void DrawCallback_SetSamplerNearest(const ImDrawList*, const ImDrawCmd*) { g_MarkerCalls[2] = 3; }++// Blender widgets (BUI_IMGUI_BLENDER_WIDGETS, blender/imgui_widgets_blender.cpp): the+// callback data is a BKWidgetDraw followed by its two NUL-terminated texts; RenderDrawData+// draws it with BK_draw_widget, in draw order, clipped to the command's clip rect.+void ImGui_ImplBUI_DrawCallback_Widget(const ImDrawList*, const ImDrawCmd*) { g_MarkerCalls[3] = 4; }++#ifdef BUI_IMGUI_BLENDER_WIDGETS+bool g_ImGui_ImplBUI_BlenderWidgets = true; // read by imgui_widgets_blender.cpp+bool ImGui_ImplBUI_HasBlenderWidgets() { return true; }+#else+bool g_ImGui_ImplBUI_BlenderWidgets = false;+bool ImGui_ImplBUI_HasBlenderWidgets() { return false; }+#endif+void ImGui_ImplBUI_SetBlenderWidgets(bool on) { g_ImGui_ImplBUI_BlenderWidgets = on && ImGui_ImplBUI_HasBlenderWidgets(); }+bool ImGui_ImplBUI_GetBlenderWidgets() { return g_ImGui_ImplBUI_BlenderWidgets; }++static void DrawWidget(const ImDrawCmd& cmd, BuiRaster* r, float dx, float dy)+{+ if (cmd.UserCallbackData == nullptr || cmd.UserCallbackDataSize < (int)sizeof(BKWidgetDraw) + 2)+ return;+ BKWidgetDraw w;+ memcpy(&w, cmd.UserCallbackData, sizeof(w));+ const char* text = (const char*)cmd.UserCallbackData + sizeof(BKWidgetDraw);+ w.text = text;+ w.text2 = text + strlen(text) + 1;+ w.rect[0] += dx;+ w.rect[1] += dy;+ w.text_rect[0] += dx;+ w.text_rect[1] += dy;+ if (w.aux[0] != 0.0f)+ w.aux[0] += dx;+ if (w.aux[1] != 0.0f)+ w.aux[1] += dy;+ // the command's clip, narrowed by the widget's own+ ImVec4 c = cmd.ClipRect;+ if (w.clip[2] > w.clip[0])+ c = ImVec4(ImMax(c.x, w.clip[0]), ImMax(c.y, w.clip[1]), ImMin(c.z, w.clip[2]), ImMin(c.w, w.clip[3]));+ if (c.z <= c.x || c.w <= c.y)+ return;+ w.clip[0] = c.x + dx;+ w.clip[1] = c.y + dy;+ w.clip[2] = c.z + dx;+ w.clip[3] = c.w + dy;+ BK_draw_widget(r, &w);+}static void UploadRect(ImTextureData* tex, int tex_id, int x, int y, int w, int h){@@ -169,6 +216,8 @@ void ImGui_ImplBUI_RenderDrawData(ImDrawData* draw_data, BuiRaster* r, float ox,{if (cmd.UserCallback == DrawCallback_SetSamplerNearest)nearest = BUI_MESH_NEAREST;+ else if (cmd.UserCallback == ImGui_ImplBUI_DrawCallback_Widget)+ DrawWidget(cmd, r, dx, dy);else if (cmd.UserCallback == DrawCallback_SetSamplerLinear || cmd.UserCallback == DrawCallback_ResetRenderState ||cmd.UserCallback == platform_io.DrawCallback_ResetRenderState)nearest = 0;@@ -429,6 +478,8 @@ static uint64_t HashDrawData(const ImDrawData* dd)h = HashMix(h, (uint64_t)cmd.GetTexID());h = HashMix(h, ((uint64_t)cmd.VtxOffset << 32) ^ cmd.IdxOffset ^ ((uint64_t)cmd.ElemCount << 16));h = HashMix(h, (uint64_t)(uintptr_t)cmd.UserCallback);+ if (cmd.UserCallback != nullptr && cmd.UserCallbackData != nullptr && cmd.UserCallbackDataSize > 0)+ h = HashBytes(h, cmd.UserCallbackData, (size_t)cmd.UserCallbackDataSize);}}return h;diff --git a/bindings/imgui/imgui_impl_bui.h b/bindings/imgui/imgui_impl_bui.hindex 3862777..ace6eda 100644--- a/bindings/imgui/imgui_impl_bui.h+++ b/bindings/imgui/imgui_impl_bui.h@@ -100,6 +100,16 @@ IMGUI_IMPL_API float ImGui_ImplBUI_BlenderFontSize(float scale = 1.0f);// BUI build has no embedded font.IMGUI_IMPL_API ImFont* ImGui_ImplBUI_AddBlenderFont(float size_pixels = 0.0f);+// Blender widgets (CMake BUI_IMGUI_BLENDER_WIDGETS=ON: blender/imgui_widgets_blender.cpp+// replaces imgui_widgets.cpp): ImGui's widgets drawn by the kit as Blender's widgets and+// handled with Blender's interaction rules. HasBlenderWidgets: built with them;+// SetBlenderWidgets: runtime switch (on by default when built; off draws ImGui's own).+IMGUI_IMPL_API bool ImGui_ImplBUI_HasBlenderWidgets();+IMGUI_IMPL_API void ImGui_ImplBUI_SetBlenderWidgets(bool on);+IMGUI_IMPL_API bool ImGui_ImplBUI_GetBlenderWidgets();+// The draw callback marker those widgets emit (data: BKWidgetDraw + its texts).+IMGUI_IMPL_API void ImGui_ImplBUI_DrawCallback_Widget(const ImDrawList* list, const ImDrawCmd* cmd);+// A complete app: a native BUI window (or, without a window system, nothing) whose whole// client area is one ImGui node. CreateApp needs a current ImGui context.struct ImGui_ImplBUI_App;diff --git a/bindings/imgui/tests/test_cimgui.c b/bindings/imgui/tests/test_cimgui.cindex 3a2921e..ecc6e6f 100644--- a/bindings/imgui/tests/test_cimgui.c+++ b/bindings/imgui/tests/test_cimgui.c@@ -213,7 +213,17 @@ int main(void)CHECK(s.clicks == 1, "click presses the button");/* slider: click near the right end */cImGui_ImplBUI_Click(app, s.slider_rc.min.x + s.slider_w * 0.8f, Center(s.slider_rc).y);- CHECK(s.slider > 0.6f, "click on the slider sets it");+ if (cImGui_ImplBUI_GetBlenderWidgets())+ {+ /* variant (Blender widgets): a click types a value instead of jumping to the pointer */+ CHECK(io->WantTextInput && fabsf(s.slider - 0.25f) < 1e-4f, "click on the slider types a value (Blender widgets)");+ cImGui_ImplBUI_Key(app, "a", 2 /* BK_CTRL */);+ cImGui_ImplBUI_TypeText(app, "0.8");+ cImGui_ImplBUI_Key(app, "Return", 0);+ CHECK(fabsf(s.slider - 0.8f) < 1e-4f, "typed 0.8 into the slider");+ }+ else+ CHECK(s.slider > 0.6f, "click on the slider sets it");/* text */cImGui_ImplBUI_Click(app, Center(s.input).x, Center(s.input).y);cImGui_ImplBUI_TypeText(app, "Hi C");diff --git a/bindings/imgui/tests/test_imgui_bui.cpp b/bindings/imgui/tests/test_imgui_bui.cppindex f377ee9..9949209 100644--- a/bindings/imgui/tests/test_imgui_bui.cpp+++ b/bindings/imgui/tests/test_imgui_bui.cpp@@ -7,7 +7,11 @@// and copied to the clipboard, the wheel scrolls, the cursor shape follows;// - an idle UI runs no frames; input runs one;// - the font atlas reaches the raster (text pixels), and the GPU renderer (when a device-// exists) draws the same frame as the software raster.+// exists) draws the same frame as the software raster;+// - with Blender widgets (BUI_IMGUI_BLENDER_WIDGETS): Blender's interaction rules (number+// field drag steps, Shift precision, Ctrl snapping, click arrows, click / double-click to+// type, relative slider drags, checkbox drag-toggle). Expectations that differ from+// ImGui's own widgets are marked "variant".// BUI_IMGUI_SHOT=dir writes PNG screenshots (CPU and GPU).//// SPDX-License-Identifier: GPL-2.0-or-later@@ -71,6 +75,9 @@ struct TestStatechar text[64] = "";int clicks = 0;bool demo = true;+ float drag = 0.0f;+ bool check2 = false;+ ImRect drag_rc, check2_rc;float slider_w = 0.0f;ImRect check, slider_rc, input, button, empty;};@@ -92,6 +99,10 @@ static void Frame(void*)if (ImGui::Button("Button"))T.clicks++;T.button = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());+ ImGui::DragFloat("Drag", &T.drag, 0.01f, 0.0f, 0.0f, "%.3f");+ T.drag_rc = ImRect(ImGui::GetItemRectMin(), ImVec2(ImGui::GetItemRectMin().x + ImGui::CalcItemWidth(), ImGui::GetItemRectMax().y));+ ImGui::Checkbox("Check 2", &T.check2);+ T.check2_rc = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());ImGui::Dummy(ImVec2(200, 60));T.empty = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());ImGui::End();@@ -118,6 +129,19 @@ static ImVec2 Center(const ImRect& r) { return ImVec2((r.Min.x + r.Max.x) * 0.5fstatic void Move(float x, float y) { BK_motion(g_ctx, (int)x, (int)y, 0); Render(2); }static void Press(float x, float y) { BK_motion(g_ctx, (int)x, (int)y, 0); Render(1); BK_press(g_ctx, (int)x, (int)y, BK_BUTTON1); Render(2); }static void Release(float x, float y) { BK_release(g_ctx, (int)x, (int)y, 0); Render(3); }+// a drag in steps of `step` px with the button held (and `mods`), then the release+static void Drag(float x0, float y, float dx, int mods, float step = 10.0f)+{+ Press(x0, y);+ const int n = (int)ceilf(fabsf(dx) / step);+ for (int i = 1; i <= n; i++)+ {+ BK_motion(g_ctx, (int)(x0 + dx * i / n), (int)y, BK_BUTTON1 | mods);+ Render(1);+ }+ BK_release(g_ctx, (int)(x0 + dx), (int)y, mods);+ Render(3);+}static void Click(float x, float y) { Press(x, y); Release(x, y); }// typed characters arrive as text with the character as key name (Win32's WM_CHAR path),@@ -228,6 +252,8 @@ int main()}// -- slider drag --+ const bool blender = ImGui_ImplBUI_GetBlenderWidgets();+ printf("info widgets: %s\n", blender ? "Blender widgets (BUI_IMGUI_BLENDER_WIDGETS)" : "Dear ImGui widgets");{const ImVec2 c = Center(T.slider_rc);const float w = T.slider_w;@@ -240,7 +266,10 @@ int main()Render(1);}Release(x1, c.y);- CHECK(at_press < 0.05f && T.slider > 0.95f, "slider dragged from %.3f to %.3f", at_press, T.slider);+ if (blender) // variant: Blender's sliders move relative to the press, no jump to the click+ CHECK(fabsf(at_press - 0.25f) < 1e-4f && T.slider > 0.95f, "slider dragged (relative, Blender) from %.3f to %.3f", at_press, T.slider);+ else+ CHECK(at_press < 0.05f && T.slider > 0.95f, "slider dragged from %.3f to %.3f", at_press, T.slider);}// -- button --@@ -274,6 +303,84 @@ int main()CHECK(!io.WantTextInput, "text field released by a click elsewhere");}+ // -- Blender interaction (variant) --+ if (blender)+ {+ const ImVec2 c = Center(T.drag_rc);+ T.drag = 0.0f;+ Drag(c.x, c.y, 60.0f, 0);+ CHECK(fabsf(T.drag - 0.57f) < 0.011f, "DragFloat drag 60 px at speed 0.01: %.3f (Blender: v_speed per px past the 3 px origin)", T.drag);+ T.drag = 0.0f;+ Drag(c.x, c.y, 60.0f, BK_SHIFT);+ CHECK(fabsf(T.drag - 0.057f) < 0.002f, "Shift drag: precision, 1/10 the speed: %.3f", T.drag);+ T.drag = 0.0f;+ Drag(c.x, c.y, 160.0f, BK_CTRL);+ CHECK(T.drag == 2.0f, "Ctrl drag snaps (unbounded float: whole units): %.3f", T.drag);+ T.drag = 0.0f;+ Drag(c.x, c.y, 60.0f, BK_CTRL | BK_SHIFT);+ CHECK(fabsf(T.drag - 0.1f * roundf(T.drag * 10.0f)) < 1e-4f && T.drag > 0.0f, "Ctrl+Shift drag snaps to tenths: %.3f", T.drag);+ T.drag = 1.0f;+ Click(T.drag_rc.Min.x + 3, c.y);+ CHECK(fabsf(T.drag - 0.99f) < 1e-4f, "click on the left arrow steps down: %.3f", T.drag);+ Click(T.drag_rc.Max.x - 3, c.y);+ Click(T.drag_rc.Max.x - 3, c.y);+ CHECK(fabsf(T.drag - 1.01f) < 1e-4f, "two clicks on the right arrow step up: %.3f", T.drag);+ Move(c.x, c.y);+ CHECK(BK_cursor(g_ctx) == BK_CURSOR_EW, "Blender's horizontal-arrows cursor over number fields (%d)", BK_cursor(g_ctx));+ Click(c.x, c.y);+ CHECK(io.WantTextInput, "a click (no drag) in the middle types a value");+ Key("a", BK_CTRL);+ Type("0.25");+ Key("Return", 0);+ CHECK(fabsf(T.drag - 0.25f) < 1e-4f && !io.WantTextInput, "typed 0.25 + Return: %.3f", T.drag);+ // double-click: text editing as well+ Press(c.x, c.y);+ BK_release(g_ctx, (int)c.x, (int)c.y, 0);+ Render(2); // (WantTextInput follows a frame later)+ CHECK(io.WantTextInput, "double-click (first click) enters text editing");+ BK_press(g_ctx, (int)c.x, (int)c.y, BK_BUTTON1);+ BK_release(g_ctx, (int)c.x, (int)c.y, 0);+ Render(3);+ CHECK(io.WantTextInput, "double-click keeps text editing (selects the word)");+ Key("Escape", 0);+ CHECK(!io.WantTextInput && fabsf(T.drag - 0.25f) < 1e-4f, "Escape leaves text editing, value kept %.3f", T.drag);+ // Ctrl+click: types too+ BK_motion(g_ctx, (int)c.x, (int)c.y, 0);+ Render(1);+ BK_key(g_ctx, "", "Control_L", BK_CTRL);+ Render(1);+ BK_press(g_ctx, (int)c.x, (int)c.y, BK_BUTTON1 | BK_CTRL);+ Render(2);+ BK_release(g_ctx, (int)c.x, (int)c.y, BK_CTRL);+ BK_key_release(g_ctx, "Control_L", 0);+ Render(3);+ CHECK(io.WantTextInput, "Ctrl+click types a value");+ Key("Escape", 0);+ // a slider click (no drag) types too+ Click(Center(T.slider_rc).x, Center(T.slider_rc).y);+ CHECK(io.WantTextInput, "slider: a click types a value (Blender), no jump");+ Key("Escape", 0);+ // checkbox drag-toggle: press one, drag over the other+ T.checked = false;+ T.check2 = false;+ const float h = T.check.GetHeight();+ Press(T.check.Min.x + h * 0.5f, T.check.Min.y + h * 0.5f);+ CHECK(T.checked, "checkbox toggles on press (Blender)");+ for (float y = T.check.Min.y + h * 0.5f; y <= T.check2_rc.Min.y + h * 0.5f; y += 8.0f)+ {+ BK_motion(g_ctx, (int)(T.check.Min.x + h * 0.5f), (int)y, BK_BUTTON1);+ Render(1);+ }+ BK_motion(g_ctx, (int)(T.check2_rc.Min.x + h * 0.5f), (int)(T.check2_rc.Min.y + h * 0.5f), BK_BUTTON1);+ Render(2);+ Release(T.check2_rc.Min.x + h * 0.5f, T.check2_rc.Min.y + h * 0.5f);+ CHECK(T.checked && T.check2, "drag-toggle: dragging over the second checkbox turned it on too (%d %d)", T.checked, T.check2);+ T.checked = false;+ T.check2 = false;+ Render(2);+ Move(Center(T.empty).x, Center(T.empty).y);+ }+// -- idle: no frames without input --{Move(Center(T.empty).x, Center(T.empty).y);@@ -315,7 +422,22 @@ int main()bad += d > 8;}CHECK(ImGui_ImplBUI_FrameCount() == f0, "GPU render replayed the frame without running ImGui");- CHECK(bad < W * H / 1000, "GPU frame matches the software raster: %d pixels differ by more than 8 (max %d)", bad, maxd);+ if (blender)+ {+ // variant: the kit's text (BUI's own glyph rendering) differs by AA levels between+ // the renderers, as in gpu/tests/test_gpu_parity.c: only gross differences count+ int gross = 0;+ for (size_t i = 0; i < cpu_copy.size(); i++)+ {+ int d = 0;+ for (int s = 0; s < 24; s += 8)+ d = ImMax(d, abs((int)((cpu_copy[i] >> s) & 0xFF) - (int)((gp[i] >> s) & 0xFF)));+ gross += d > 64;+ }+ CHECK(bad < W * H / 100 && gross < W * H / 2000, "GPU frame matches the software raster (text AA aside): %d pixels differ by more than 8, %d by more than 64 (max %d)", bad, gross, maxd);+ }+ else+ CHECK(bad < W * H / 1000, "GPU frame matches the software raster: %d pixels differ by more than 8 (max %d)", bad, maxd);Shot("imgui_gpu.png", gp);}elsediff --git a/bindings/python/bui/__pycache__/host.cpython-314.pyc b/bindings/python/bui/__pycache__/host.cpython-314.pycindex b7faa40..d8ef257 100644Binary files a/bindings/python/bui/__pycache__/host.cpython-314.pyc and b/bindings/python/bui/__pycache__/host.cpython-314.pyc differdiff --git a/bindings/python/bui/__pycache__/imgui.cpython-314.pyc b/bindings/python/bui/__pycache__/imgui.cpython-314.pycnew file mode 100644index 0000000..d356eb6Binary files /dev/null and b/bindings/python/bui/__pycache__/imgui.cpython-314.pyc differdiff --git a/bindings/python/src/buiimgui_module.cpp b/bindings/python/src/buiimgui_module.cppindex 978e23b..53b2ccb 100644--- a/bindings/python/src/buiimgui_module.cpp+++ b/bindings/python/src/buiimgui_module.cpp@@ -298,6 +298,17 @@ static PyObject* bi_style_blender(PyObject*, PyObject* args)static PyObject* bi_get_scale(PyObject*, PyObject*) { return PyFloat_FromDouble(cimgui::cImGui_ImplBUI_GetScale()); }+static PyObject* bi_has_blender_widgets(PyObject*, PyObject*) { return PyBool_FromLong(cimgui::cImGui_ImplBUI_HasBlenderWidgets()); }+static PyObject* bi_get_blender_widgets(PyObject*, PyObject*) { return PyBool_FromLong(cimgui::cImGui_ImplBUI_GetBlenderWidgets()); }+static PyObject* bi_set_blender_widgets(PyObject*, PyObject* arg)+{+ const int on = PyObject_IsTrue(arg);+ if (on < 0)+ return nullptr;+ cimgui::cImGui_ImplBUI_SetBlenderWidgets(on != 0);+ Py_RETURN_NONE;+}+static PyObject* bi_set_scale(PyObject*, PyObject* args){float s;@@ -317,6 +328,9 @@ static PyObject* bi_sizeof(PyObject*, PyObject* args)static PyMethodDef bi_module_methods_extra[] = {{ "style_blender", bi_style_blender, METH_VARARGS, "style_blender(scale=1.0) -- Blender's theme on the current style" },+ { "has_blender_widgets", bi_has_blender_widgets, METH_NOARGS, "has_blender_widgets() -- built with Blender's widgets (BUI_IMGUI_BLENDER_WIDGETS)" },+ { "get_blender_widgets", bi_get_blender_widgets, METH_NOARGS, "get_blender_widgets() -- ImGui's widgets are drawn and handled as Blender's" },+ { "set_blender_widgets", bi_set_blender_widgets, METH_O, "set_blender_widgets(on) -- switch Blender's widgets on or off (when built with them)" },{ "get_ui_scale", bi_get_scale, METH_NOARGS, "get_ui_scale() -> BUI's UI scale (DPI)" },{ "set_ui_scale", bi_set_scale, METH_VARARGS, "set_ui_scale(scale)" },{ "_sizeof", bi_sizeof, METH_VARARGS, "_sizeof(type_name) -> sizeof() in C++ (tests)" },diff --git a/bindings/python/tests/test_imgui.py b/bindings/python/tests/test_imgui.pyindex 82eb7eb..716f595 100644--- a/bindings/python/tests/test_imgui.py+++ b/bindings/python/tests/test_imgui.py@@ -207,21 +207,36 @@ class ImGuiTest(unittest.TestCase):self.click("button")self.assertEqual(self.ui.clicks, n + 1)- def test_slider_click(self):+ def slider_click(self, fx, typed):(x0, y0), (x1, y1) = self.ui.rects["slider"]- self.app.click(x0 + self.ui.slider_w * 0.9, (y0 + y1) / 2)+ self.app.click(x0 + self.ui.slider_w * fx, (y0 + y1) / 2)+ if imgui.get_blender_widgets():+ # variant (Blender widgets): a click types a value, no jump to the pointer+ self.app.key("a", imgui.BK_CTRL)+ self.app.type_text(typed)+ self.app.key("Return")++ def test_slider_click(self):+ self.slider_click(0.9, "0.9")self.assertGreater(self.ui.slider, 0.8)- self.app.click(x0 + self.ui.slider_w * 0.1, (y0 + y1) / 2)+ self.slider_click(0.1, "0.1")self.assertLess(self.ui.slider, 0.2)def test_slider_drag(self):(x0, y0), (x1, y1) = self.ui.rects["slider"]y = (y0 + y1) / 2+ before = self.ui.sliderself.app.mouse_down(x0 + self.ui.slider_w * 0.2, y)self.app.mouse_move(x0 + self.ui.slider_w * 0.5, y)self.app.mouse_move(x0 + self.ui.slider_w * 0.7, y)self.app.mouse_up(x0 + self.ui.slider_w * 0.7, y)- self.assertAlmostEqual(self.ui.slider, 0.7, delta=0.06)+ # variant (Blender widgets): relative to the value at the press (half the width: +0.5)+ expected = min(1.0, before + 0.5) if imgui.get_blender_widgets() else 0.7+ self.assertAlmostEqual(self.ui.slider, expected, delta=0.06)++ def test_blender_widgets_switch(self):+ self.assertIsInstance(imgui.has_blender_widgets(), bool)+ self.assertEqual(imgui.get_blender_widgets(), imgui.has_blender_widgets())def test_typing(self):self.click("input")diff --git a/bindings/rust/blenderui-imgui/Cargo.toml b/bindings/rust/blenderui-imgui/Cargo.tomlindex bc1ad4b..7469729 100644--- a/bindings/rust/blenderui-imgui/Cargo.toml+++ b/bindings/rust/blenderui-imgui/Cargo.toml@@ -12,3 +12,7 @@ categories = ["gui", "api-bindings"][dependencies]# builds and links bui_cimgui (Dear ImGui + its C API + the BUI backend) with the C kitblenderui-sys = { path = "../blenderui-sys", version = "0.1.0", features = ["imgui"] }++[features]+# ImGui's widgets drawn and handled as Blender's widgets (bindings/imgui/blender)+blender-widgets = ["blenderui-sys/imgui-blender-widgets"]diff --git a/bindings/rust/blenderui-imgui/src/lib.rs b/bindings/rust/blenderui-imgui/src/lib.rsindex 5785ac2..f026f66 100644--- a/bindings/rust/blenderui-imgui/src/lib.rs+++ b/bindings/rust/blenderui-imgui/src/lib.rs@@ -237,6 +237,9 @@ unsafe extern "C" {fn cImGui_ImplBUI_FrameCount() -> c_int;fn cImGui_ImplBUI_StyleBlender(dst: *mut ImGuiStyle, scale: f32);fn cImGui_ImplBUI_GetScale() -> f32;+ fn cImGui_ImplBUI_HasBlenderWidgets() -> bool;+ fn cImGui_ImplBUI_SetBlenderWidgets(on: bool);+ fn cImGui_ImplBUI_GetBlenderWidgets() -> bool;fn cImGui_ImplBUI_SetScale(scale: f32);}@@ -245,6 +248,22 @@ pub fn style_blender(style: Option<&mut ImGuiStyle>, scale: f32) {unsafe { cImGui_ImplBUI_StyleBlender(style.map_or(core::ptr::null_mut(), |s| s as *mut _), scale) }}+/// Built with Blender's widgets (feature `blender-widgets`, CMake BUI_IMGUI_BLENDER_WIDGETS):+/// ImGui's widgets drawn and handled as Blender's.+pub fn has_blender_widgets() -> bool {+ unsafe { cImGui_ImplBUI_HasBlenderWidgets() }+}++/// Whether Blender's widgets are in use (on by default when built with them).+pub fn blender_widgets() -> bool {+ unsafe { cImGui_ImplBUI_GetBlenderWidgets() }+}++/// Switches Blender's widgets on or off at runtime (no effect when not built with them).+pub fn set_blender_widgets(on: bool) {+ unsafe { cImGui_ImplBUI_SetBlenderWidgets(on) }+}+/// BUI's UI scale (DPI).pub fn ui_scale() -> f32 {unsafe { cImGui_ImplBUI_GetScale() }diff --git a/bindings/rust/blenderui-imgui/tests/headless.rs b/bindings/rust/blenderui-imgui/tests/headless.rsindex d8186e6..0d423d7 100644--- a/bindings/rust/blenderui-imgui/tests/headless.rs+++ b/bindings/rust/blenderui-imgui/tests/headless.rs@@ -138,6 +138,12 @@ fn headless_widgets_and_input() {let (a, b) = st.borrow().rects["slider"];let w = st.borrow().slider_w;app.click(a.x + w * 0.9, (a.y + b.y) / 2.0);+ if blenderui_imgui::blender_widgets() {+ // variant (Blender widgets): a click types a value instead of jumping to the pointer+ app.key("a", 2); // BK_CTRL+ app.type_text("0.9");+ app.key("Return", 0);+ }assert!(st.borrow().slider > 0.8, "slider {}", st.borrow().slider);// textlet (x, y) = center(&st, "input");diff --git a/bindings/rust/blenderui-sys/Cargo.toml b/bindings/rust/blenderui-sys/Cargo.tomlindex 00c95ca..a9970fe 100644--- a/bindings/rust/blenderui-sys/Cargo.toml+++ b/bindings/rust/blenderui-sys/Cargo.toml@@ -26,6 +26,9 @@ portable-text = []# Also build and link Dear ImGui on BUI and its C API (bindings/imgui: bui_cimgui,# bui_imgui; C++). Used by the blenderui-imgui crate.imgui = []+# With `imgui`: ImGui's widgets drawn and handled as Blender's widgets (CMake+# BUI_IMGUI_BLENDER_WIDGETS; bindings/imgui/blender). Same API.+imgui-blender-widgets = ["imgui"][build-dependencies]cmake = "0.1"diff --git a/bindings/rust/blenderui-sys/build.rs b/bindings/rust/blenderui-sys/build.rsindex 844595f..369a435 100644--- a/bindings/rust/blenderui-sys/build.rs+++ b/bindings/rust/blenderui-sys/build.rs@@ -32,6 +32,7 @@ fn main() {.define("BUI_BUILD_UI", "OFF").define("BUI_BUILD_QT_BACKEND", "OFF").define("BUI_BUILD_IMGUI", if imgui { "ON" } else { "OFF" })+ .define("BUI_IMGUI_BLENDER_WIDGETS", if std::env::var("CARGO_FEATURE_IMGUI_BLENDER_WIDGETS").is_ok() { "ON" } else { "OFF" })// Always optimized; on MSVC also the release C runtime Rust links..profile("Release").build_target(if imgui { "bui_cimgui" } else { "bui_kit" })diff --git a/compat/intern/bui_stubs.cc b/compat/intern/bui_stubs.ccindex 56f9a37..0399697 100644Binary files a/compat/intern/bui_stubs.cc and b/compat/intern/bui_stubs.cc differdiff --git a/docs/imgui.md b/docs/imgui.mdindex 8c36f29..c633d68 100644--- a/docs/imgui.md+++ b/docs/imgui.md@@ -23,6 +23,7 @@ The C, Python and Rust bindings are **generated** from `imgui.h`; see- [Python](#python)- [Rust](#rust)- [Headless rendering and tests](#headless-rendering-and-tests)+- [Blender widgets](#blender-widgets)- [Coverage](#coverage)- [Regenerating](#regenerating)- [Limitations](#limitations)@@ -225,7 +226,28 @@ Tests:| `imgui_c_api` (ctest) | `bindings/imgui/tests/test_cimgui.c`: widgets, tables, list clipper, draw list, popups, IO/style structs, helpers, text filter/storage/text buffer, clicks, a slider, typing || `buipy_imgui` (ctest) | `bindings/python/tests/test_imgui.py` (unittest): the same from Python, plus drags, the wheel, buffer growth, overload dispatch, struct fields and array views, the demo/metrics/style windows, errors || `cargo test -p blenderui-imgui` | `tests/headless.rs`: Rust/C++ struct sizes, widgets and input, owned objects, a panic in the frame |-| `imgui_backend` (ctest) | the backend itself, in C++ (phase 1) |+| `imgui_backend` (ctest) | the backend itself, in C++ (phase 1); with Blender widgets also their interaction (drag steps, Shift, Ctrl snapping, arrows, click / double-click / Ctrl+click to type, relative sliders, drag-toggle) |+| `imgui_blender_widgets_match_kit` (ctest, `BUI_IMGUI_BLENDER_WIDGETS=ON`) | `examples/imgui_blender_compare.cpp`: ImGui's Blender widgets and the kit's native widgets are the same pixels |++The C, Python and C++ tests run in both widget variants; expectations that differ with+Blender widgets (sliders do not jump to the pointer, a click types a value) are marked+"variant" in them.++## Blender widgets++Built with `-DBUI_IMGUI_BLENDER_WIDGETS=ON` (Rust: `blenderui-imgui` feature+`blender-widgets`), Dear ImGui's widgets are Blender's widgets: drawn by the BUI kit with+its own widget drawing and handled with Blender's rules where they differ (number fields,+sliders, checkboxes). Nothing changes in the API; the switch is also available at runtime:++| | C++ | C | Python | Rust |+|---|---|---|---|---|+| built with them | `ImGui_ImplBUI_HasBlenderWidgets()` | `cImGui_ImplBUI_HasBlenderWidgets()` | `imgui.has_blender_widgets()` | `has_blender_widgets()` |+| in use | `ImGui_ImplBUI_GetBlenderWidgets()` | `cImGui_ImplBUI_GetBlenderWidgets()` | `imgui.get_blender_widgets()` | `blender_widgets()` |+| switch | `ImGui_ImplBUI_SetBlenderWidgets(on)` | `cImGui_ImplBUI_SetBlenderWidgets(on)` | `imgui.set_blender_widgets(on)` | `set_blender_widgets(on)` |++The widget mapping, the behavior differences and the gaps are in+[bindings/imgui/blender/README.md](../bindings/imgui/blender/README.md).## Coveragediff --git a/examples/imgui_blender_compare.cpp b/examples/imgui_blender_compare.cppnew file mode 100644index 0000000..0939bac--- /dev/null+++ b/examples/imgui_blender_compare.cpp@@ -0,0 +1,286 @@+// Dear ImGui's widgets next to BUI's native kit widgets, in one BUI frame: the left column+// is the kit (BK_node_new("checkbox"), "number", ...), the right one the same widgets+// through ImGui. Built with BUI_IMGUI_BLENDER_WIDGETS=ON the two columns should match+// pixel for pixel in style; without it the right column shows ImGui's own widgets in the+// Blender colors. Also renders ShowDemoWindow() with sections open, and an open menu.+//+// bui_imgui_compare out_dir writes compare.png, demo.png, demo_menu.png (headless)+//+// SPDX-License-Identifier: GPL-2.0-or-later++#include "imgui.h"+#include "imgui_internal.h"+#include "imgui_impl_bui.h"++#include "BUI_kit.h"+#include "bui_png.h"++#include <cmath>+#include <cstdio>+#include <cstdlib>+#include <string>++static const int COL_W = 300;++struct State+{+ bool check = true, check2 = false;+ float number = 0.5f, slider = 0.25f;+ float vec[3] = { 1.0f, 0.0f, 2.5f };+ char text[64] = "Edit me";+ int combo = 0, radio = 0;+ float color[4] = { 0.278f, 0.447f, 0.702f, 1.0f };+ bool demo = false;+ int mode = 0; // 0: the comparison, 1: the demo window+};+static State S;+static ImRect g_items[16]; // the ImGui column's items, for the pixel comparison+static int g_nitems = 0;+static void Item() { if (g_nitems < 16) g_items[g_nitems++] = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); }++static void ImGuiColumn()+{+ ImGui::SetNextWindowPos(ImVec2(0, 0));+ ImGui::SetNextWindowSize(ImVec2((float)COL_W, 400));+ ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));+ ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f); // (the border would clip a pixel)+ ImGui::Begin("compare", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoSavedSettings);+ g_nitems = 0;+ ImGui::PushItemWidth(-FLT_MIN);+ ImGui::Checkbox("Checkbox", &S.check);+ Item();+ ImGui::Checkbox("Option", &S.check2);+ Item();+ ImGui::DragFloat("##number", &S.number, 0.01f, 0.0f, 0.0f, "Number: %.3f");+ Item();+ ImGui::SliderFloat("##slider", &S.slider, 0.0f, 1.0f, "Slider: %.3f");+ Item();+ ImGui::DragFloat3("##vec", S.vec, 0.01f, 0.0f, 0.0f, "%.3f");+ Item();+ ImGui::InputText("##text", S.text, sizeof(S.text));+ Item();+ ImGui::Button("Button", ImVec2(-FLT_MIN, 0));+ Item();+ ImGui::Combo("##combo", &S.combo, "Alpha\0Beta\0Gamma\0");+ Item();+ ImGui::ProgressBar(0.6f, ImVec2(-FLT_MIN, 0));+ Item();+ ImGui::ColorButton("##swatch", ImVec4(S.color[0], S.color[1], S.color[2], S.color[3]), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetContentRegionAvail().x, ImGui::GetFrameHeight()));+ Item();+ ImGui::PopItemWidth();+ ImGui::End();+ ImGui::PopStyleVar(2);+}++static void Frame(void*)+{+ if (S.mode == 0)+ {+ ImGuiColumn();+ return;+ }+ // the demo window, large, plus a window of our own with a menu bar+ ImGui::ShowDemoWindow(&S.demo);+ ImGui::SetNextWindowPos(ImVec2(20, 20), ImGuiCond_Always);+ ImGui::SetNextWindowSize(ImVec2(360, 420), ImGuiCond_Always);+ ImGui::Begin("Custom window", nullptr, ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoSavedSettings);+ if (ImGui::BeginMenuBar())+ {+ if (ImGui::BeginMenu("File"))+ {+ ImGui::MenuItem("New", "Ctrl N");+ ImGui::MenuItem("Open...", "Ctrl O");+ static bool autosave = true;+ ImGui::MenuItem("Auto Save", nullptr, &autosave);+ ImGui::Separator();+ if (ImGui::BeginMenu("Export"))+ {+ ImGui::MenuItem("glTF");+ ImGui::EndMenu();+ }+ ImGui::MenuItem("Quit", "Ctrl Q");+ ImGui::EndMenu();+ }+ if (ImGui::BeginMenu("Edit"))+ ImGui::EndMenu();+ ImGui::EndMenuBar();+ }+ ImGui::Text("Blender widgets: %s", ImGui_ImplBUI_GetBlenderWidgets() ? "on" : "off");+ ImGui::Checkbox("Checkbox", &S.check);+ ImGui::RadioButton("One", &S.radio, 0); ImGui::SameLine();+ ImGui::RadioButton("Two", &S.radio, 1);+ ImGui::DragFloat("Drag", &S.number, 0.01f);+ ImGui::SliderFloat("Slider", &S.slider, 0.0f, 1.0f);+ ImGui::DragFloat3("Vector", S.vec, 0.01f);+ ImGui::InputText("Text", S.text, sizeof(S.text));+ ImGui::Combo("Combo", &S.combo, "Alpha\0Beta\0Gamma\0");+ ImGui::ColorEdit4("Color", S.color);+ ImGui::ProgressBar(0.6f);+ if (ImGui::Button("Button")) {}+ ImGui::SameLine();+ ImGui::SmallButton("Small");+ ImGui::SameLine();+ ImGui::ArrowButton("##left", ImGuiDir_Left);+ if (ImGui::CollapsingHeader("Collapsing header", ImGuiTreeNodeFlags_DefaultOpen))+ {+ if (ImGui::TreeNode("Tree node"))+ {+ ImGui::Selectable("Selectable", true);+ ImGui::Selectable("Another");+ ImGui::TreePop();+ }+ }+ if (ImGui::BeginTabBar("tabs"))+ {+ if (ImGui::BeginTabItem("Tab A")) { ImGui::Text("Contents A"); ImGui::EndTabItem(); }+ if (ImGui::BeginTabItem("Tab B")) { ImGui::EndTabItem(); }+ ImGui::EndTabBar();+ }+ ImGui::End();+}++static BKNode* Add(BKNode* parent, const char* type)+{+ BKNode* n = BK_node_new(type);+ BK_node_add(parent, n, -1);+ return n;+}++static void Shot(BKContext* ctx, BuiRaster* r, int w, int h, const std::string& path)+{+ BK_render(ctx, r, w, h, 1);+ if (bui_png_write(path.c_str(), BUI_raster_pixels(r), w, h))+ printf("wrote %s\n", path.c_str());+}++int main(int argc, char** argv)+{+ const std::string dir = argc > 1 ? argv[1] : ".";+ int compare_bad = -1;+ BK_set_scale(1.0f);+ ImGui::CreateContext();+ ImGui::GetIO().IniFilename = nullptr;++ // -- the comparison: kit column | ImGui column --+ {+ const int W = 2 * COL_W + 3 * 16, H = 280;+ BKNode* root = BK_node_new("row");+ BK_set_num(root, "padding", 16);+ BK_set_num(root, "spacing", 16);+ BKNode* kit = Add(root, "column");+ BK_set_num(kit, "padding", 0);+ BK_set_num(kit, "fill", 1); // the row splits evenly: COL_W each+ BKNode* n;+ n = Add(kit, "checkbox"); BK_set_str(n, "label", "Checkbox"); BK_set_num(n, "value", 1);+ n = Add(kit, "checkbox"); BK_set_str(n, "label", "Option");+ n = Add(kit, "number"); BK_set_str(n, "label", "Number"); BK_set_num(n, "value", 0.5); BK_set_num(n, "precision", 3);+ n = Add(kit, "slider"); BK_set_str(n, "label", "Slider"); BK_set_num(n, "value", 0.25); BK_set_num(n, "precision", 3);+ BKNode* row = Add(kit, "row");+ BK_set_num(row, "align", 1);+ const double vec[3] = { 1.0, 0.0, 2.5 };+ for (double v : vec) { n = Add(row, "number"); BK_set_num(n, "value", v); BK_set_num(n, "precision", 3); BK_set_num(n, "fill", 1); }+ n = Add(kit, "text"); BK_set_str(n, "text", "Edit me");+ n = Add(kit, "button"); BK_set_str(n, "text", "Button");+ n = Add(kit, "dropdown");+ const char* items[] = { "Alpha", "Beta", "Gamma" };+ BK_set_strs(n, "items", items, 3);+ n = Add(kit, "progress"); BK_set_num(n, "factor", 0.6); BK_set_str(n, "text", "60%");+ n = Add(kit, "swatch"); BK_set_color(n, "color", S.color);+ BKNode* im = Add(root, "custom");++ BK_set_num(im, "fill", 1);+ BKContext* ctx = BK_context_new(root);+ ImGui_ImplBUI_Init(im, Frame, nullptr);+ BuiRaster* r = BUI_raster_create(W, H);+ for (int i = 0; i < 8; i++)+ BK_render(ctx, r, W, H, 1);+ Shot(ctx, r, W, H, dir + "/compare.png");+ // per widget: the kit node's pixels against the ImGui item's (same size, top-left aligned)+ {+ const uint32_t* px = BUI_raster_pixels(r);+ int nr[4];+ BK_node_rect(im, nr);+ int total_bad = 0;+ for (int i = 0; i < BK_node_child_count(kit) && i < g_nitems; i++)+ {+ int kr[4];+ BK_node_rect(BK_node_child(kit, i), kr);+ const int ix = nr[0] + (int)lroundf(g_items[i].Min.x), iy = nr[1] + (int)lroundf(g_items[i].Min.y);+ const int w = ImMin(kr[2], (int)lroundf(g_items[i].GetWidth())), h = ImMin(kr[3], (int)lroundf(g_items[i].GetHeight()));+ int bad = 0, maxd = 0;+ for (int y = 0; y < h; y++)+ for (int x = 0; x < w; x++)+ {+ const uint32_t a = px[(size_t)(kr[1] + y) * W + kr[0] + x], b = px[(size_t)(iy + y) * W + ix + x];+ int d = 0;+ for (int sh = 0; sh < 24; sh += 8)+ d = ImMax(d, abs((int)((a >> sh) & 0xFF) - (int)((b >> sh) & 0xFF)));+ maxd = ImMax(maxd, d);+ bad += d > 8;+ }+ total_bad += bad;+ printf(" %-10s kit %3dx%-3d imgui %3.0fx%-3.0f: %4d of %5d px differ by more than 8 (max %d)\n", BK_node_type(BK_node_child(kit, i)),+ kr[2], kr[3], g_items[i].GetWidth(), g_items[i].GetHeight(), bad, w * h, maxd);+ }+ printf("compare: %d px differ in total\n", total_bad);+ compare_bad = total_bad;+ }+ ImGui_ImplBUI_Shutdown();+ BUI_raster_free(r);+ BK_context_free(ctx);+ BK_node_free(root);+ }++ // -- the demo window with sections open, and a custom window with an open menu --+ {+ S.mode = 1;+ S.demo = true;+ const int W = 1280, H = 1000;+ ImGui_ImplBUI_App* app = ImGui_ImplBUI_CreateHeadlessApp(Frame, nullptr);+ BKContext* ctx = ImGui_ImplBUI_AppContext(app);+ BuiRaster* r = BUI_raster_create(W, H);+ BK_render(ctx, r, W, H, 1);+ ImGui::SetWindowPos("Dear ImGui Demo", ImVec2(400, 10));+ ImGui::SetWindowSize("Dear ImGui Demo", ImVec2(860, 980));+ if (ImGuiWindow* demo = ImGui::FindWindowByName("Dear ImGui Demo"))+ {+ const char* open[] = { "Widgets", "Basic", "Combo", "Trees", "Collapsing Headers" };+ for (const char* id : open)+ demo->DC.StateStorage->SetInt(demo->GetID(id), 1);+ }+ for (int i = 0; i < 10; i++)+ {+ ImGui_ImplBUI_RequestFrames(1);+ BK_render(ctx, r, W, H, 1);+ }+ Shot(ctx, r, W, H, dir + "/demo.png");+ // open the custom window's File menu (a click on it), hover "Open..."+ ImGuiWindow* win = ImGui::FindWindowByName("Custom window");+ if (win)+ {+ const ImRect bar = win->MenuBarRect();+ const int x = (int)bar.Min.x + 20, y = (int)bar.GetCenter().y;+ BK_motion(ctx, x, y, 0);+ BK_render(ctx, r, W, H, 0);+ BK_press(ctx, x, y, BK_BUTTON1);+ BK_render(ctx, r, W, H, 0);+ BK_release(ctx, x, y, 0);+ for (int i = 0; i < 4; i++)+ BK_render(ctx, r, W, H, 0);+ BK_motion(ctx, x + 10, y + 46, 0);+ for (int i = 0; i < 6; i++)+ BK_render(ctx, r, W, H, 0);+ }+ Shot(ctx, r, W, H, dir + "/demo_menu.png");+ BUI_raster_free(r);+ ImGui_ImplBUI_DestroyApp(app);+ }+ ImGui::DestroyContext();+ // with Blender widgets the two columns must be the same pixels (a CTest in that build)+ if (ImGui_ImplBUI_HasBlenderWidgets() && compare_bad != 0)+ {+ printf("FAIL ImGui's Blender widgets differ from the kit's native widgets\n");+ return 1;+ }+ return 0;+}diff --git a/kit/include/BUI_kit.h b/kit/include/BUI_kit.hindex 448fbe6..d4f24c2 100644--- a/kit/include/BUI_kit.h+++ b/kit/include/BUI_kit.h@@ -474,6 +474,68 @@ int BK_window_wake_init(void (*cb)(void));void BK_window_wake(void);void BK_window_set_keep_alive(int on);+/* One of Blender's widgets drawn straight into a raster, outside any BKContext: the same+ * drawing (interface_widgets.cc port, theme, Inter text) the kit's own nodes use. For+ * other toolkits drawing Blender's widgets (Dear ImGui's Blender widgets,+ * bindings/imgui/blender). Coordinates in raster pixels at BK_scale(). */+enum {+ BK_WIDGET_BUTTON = 1, /* push button (wcol_regular), text centered */+ BK_WIDGET_TOGGLE, /* toggle button (wcol_toggle), SELECTED = on */+ BK_WIDGET_CHECKBOX, /* option box + text (wcol_option), SELECTED = checked */+ BK_WIDGET_RADIO, /* round option + text, SELECTED = chosen */+ BK_WIDGET_NUMBER, /* number field with step arrows (wcol_num) */+ BK_WIDGET_SLIDER, /* number slider (wcol_numslider), value = fill factor */+ BK_WIDGET_TEXT, /* text field (wcol_text) */+ BK_WIDGET_MENU, /* menu button with the pulldown arrows (wcol_menu) */+ BK_WIDGET_PULLDOWN, /* header pulldown (wcol_pulldown) */+ BK_WIDGET_MENU_ITEM, /* menu row (wcol_menu_item); text2 = shortcut; value: 1/2 = check+ box off/on at aux[0..1], 3 = submenu arrow */+ BK_WIDGET_LIST_ITEM, /* list row (wcol_list_item) */+ BK_WIDGET_SWATCH, /* color swatch, color = rgba (checker under alpha) */+ BK_WIDGET_PROGRESS, /* progress bar (wcol_progress), value = factor */+ BK_WIDGET_TAB, /* tab (wcol_tab), SELECTED = the current tab */+ BK_WIDGET_PANEL_HEADER, /* panel header: disclosure arrow + title, OPEN */+ BK_WIDGET_DISCLOSURE, /* tree row: hover/selected row, disclosure triangle, text, OPEN;+ aux[0] = triangle center x (0: no triangle) */+ BK_WIDGET_MENU_BACK, /* menu / popup backdrop with its shadow */+ BK_WIDGET_TOOLTIP_BACK, /* tooltip backdrop */+ BK_WIDGET_SEPARATOR, /* separator line (horizontal unless h > w) */+ BK_WIDGET_LABEL, /* text alone, at text_rect, color (a < 0: theme text) */+ BK_WIDGET_ARROW, /* push button with a triangle, value = 0 right 1 down 2 left 3 up */+ BK_WIDGET_BOX, /* box backdrop (wcol_box) */+};+enum {+ BK_WS_HOVER = 1 << 0,+ BK_WS_PRESSED = 1 << 1,+ BK_WS_SELECTED = 1 << 2,+ BK_WS_DISABLED = 1 << 3,+ BK_WS_EDITING = 1 << 4, /* text being typed (text field look) */+ BK_WS_HOVER_LEFT = 1 << 5, /* number field: over the left / right step arrow */+ BK_WS_HOVER_RIGHT = 1 << 6,+ BK_WS_MIXED = 1 << 7, /* checkbox: indeterminate */+ BK_WS_FLAT = 1 << 8, /* no emboss: backdrop on hover only */+ BK_WS_OPEN = 1 << 9, /* panel header / tree row expanded */+};+/* Corners for aligned groups (Blender's CNR_*): top-left 1, top-right 2, bottom-right 4,+ * bottom-left 8; BK_CORNERS_ALL for a lone widget. */+enum { BK_CORNERS_ALL = 15 };+typedef struct BKWidgetDraw {+ int kind, state, corners;+ int align; /* text alignment: 0 left, 1 center, 2 right; -1 the widget's own */+ float rect[4]; /* x, y, w, h */+ float clip[4]; /* x0, y0, x1, y1 narrowing the raster's clip; x1 <= x0: none */+ float text_rect[4]; /* where text goes for LABEL / LIST_ITEM / MENU_ITEM / DISCLOSURE;+ w <= 0: the widget's own text placement */+ float value;+ float color[4]; /* SWATCH color; LABEL text color (a < 0: theme) */+ float aux[4];+ const char *text; /* label (UTF-8, may be NULL) */+ const char *text2; /* NUMBER / SLIDER: value text drawn right of `text`; MENU_ITEM: shortcut */+} BKWidgetDraw;+void BK_draw_widget(BuiRaster *r, const BKWidgetDraw *w);+/* Width of `s` (len < 0: NUL-terminated) in the UI font at BK_scale(). */+float BK_text_width(const char *s, int len);+/* Evaluate Blender-style number input ("2*pi", "1/3 + 2^2"). */int BK_eval_number(const char *expr, double *r_value);diff --git a/kit/intern/kit_draw.c b/kit/intern/kit_draw.cindex c99f56b..f50d907 100644--- a/kit/intern/kit_draw.c+++ b/kit/intern/kit_draw.c@@ -1674,3 +1674,460 @@ void bk_icons_draw(int id, float x, float y, float s, const float color[4])}/** \} */++/* -------------------------------------------------------------------- */+/** \name BK_draw_widget: one widget into a raster, for other toolkits+ *+ * The same drawing the kit's nodes do (button_draw, checkbox_draw, number_draw,+ * slider_draw, text_draw, dropdown_draw, menu_draw rows, list rows, swatch_draw,+ * progress_draw, tabs_draw, panel_draw), driven by a plain description instead of a+ * node. Used by Dear ImGui's Blender widgets (bindings/imgui/blender).+ * \{ */++float BK_text_width(const char *s, int len)+{+ return bk_text_width(s, len, false);+}++static int ws_state(int ws)+{+ int st = 0;+ if (ws & BK_WS_DISABLED) {+ st |= ST_DISABLED;+ }+ else if (ws & BK_WS_HOVER) {+ st |= ST_HOVER;+ }+ if (ws & (BK_WS_PRESSED | BK_WS_SELECTED)) {+ st = (st & ~ST_HOVER) | ST_SELECT;+ }+ if (ws & BK_WS_HOVER_LEFT) {+ st |= ST_HOVER_LEFT;+ }+ if (ws & BK_WS_HOVER_RIGHT) {+ st |= ST_HOVER_RIGHT;+ }+ if (ws & BK_WS_MIXED) {+ st |= ST_INDETERMINATE;+ }+ if (ws & BK_WS_FLAT) {+ st |= ST_NO_EMBOSS;+ }+ return st;+}++static BKRect wd_rect(const float f[4])+{+ const int x0 = bk_iround(f[0]), y0 = bk_iround(f[1]);+ const BKRect r = {x0, y0, bk_iround(f[0] + f[2]), bk_iround(f[1] + f[3])};+ return r;+}++/* bk_text_in, with the margin narrowed when a toolkit sized the widget to its text with less+ * padding than Blender's (ImGui: FramePadding), so short labels never elide */+static void wd_text_in(const BKRect *r, const char *s, const uchar color[4], int align)+{+ if (!s || !s[0]) {+ return;+ }+ const float tw = bk_text_width(s, -1, false);+ int pad = bk_pad();+ if (tw + 2 * pad > bk_rw(r)) {+ pad = BK_MAX(0, (int)floorf((bk_rw(r) - tw) * 0.5f));+ }+ bk_text_in_pad(r, s, color, align, false, pad);+}++/* number_texts: the label left and the value right, or the value centered */+static void wd_number_texts(const BKRect *r, const char *label, const char *val,+ const uchar color[4])+{+ BKRect tr = *r;+ if (label && label[0] && val && val[0]) {+ const float vw = bk_text_width(val, -1, false);+ BKRect lr = tr;+ lr.xmax = (int)(tr.xmax - vw - bk_pad());+ bk_text_in(&lr, label, color, BK_ALIGN_LEFT, false);+ bk_text_in(&tr, val, color, BK_ALIGN_RIGHT, false);+ }+ else {+ bk_text_in(&tr, (val && val[0]) ? val : label, color, BK_ALIGN_CENTER, false);+ }+}++/* text placed by the toolkit: from text_rect's x, vertically centered in it */+static void wd_text_at(const BKWidgetDraw *w, const BKRect *fallback, const char *s,+ const uchar color[4], int align)+{+ if (!s || !s[0]) {+ return;+ }+ if (w->text_rect[2] <= 0.0f) {+ bk_text_in(fallback, s, color, align < 0 ? BK_ALIGN_LEFT : align, false);+ return;+ }+ const BKRect tr = wd_rect(w->text_rect);+ const float tw = bk_text_width(s, -1, false);+ float x = w->text_rect[0];+ if (align == BK_ALIGN_CENTER) {+ x += (w->text_rect[2] - tw) * 0.5f;+ }+ else if (align == BK_ALIGN_RIGHT) {+ x += w->text_rect[2] - tw;+ }+ bk_text(x, bk_text_baseline(&tr), s, -1, color, false);+}++static void wd_triangle(float cx, float cy, int dir, float s, const float c[4])+{+ float p[3][2];+ switch (dir) {+ case 1: /* down */+ p[0][0] = cx - s, p[0][1] = cy - s * 0.5f, p[1][0] = cx + s, p[1][1] = cy - s * 0.5f;+ p[2][0] = cx, p[2][1] = cy + s * 0.7f;+ break;+ case 2: /* left */+ p[0][0] = cx + s * 0.5f, p[0][1] = cy - s, p[1][0] = cx + s * 0.5f, p[1][1] = cy + s;+ p[2][0] = cx - s * 0.7f, p[2][1] = cy;+ break;+ case 3: /* up */+ p[0][0] = cx - s, p[0][1] = cy + s * 0.5f, p[1][0] = cx + s, p[1][1] = cy + s * 0.5f;+ p[2][0] = cx, p[2][1] = cy - s * 0.7f;+ break;+ default: /* right */+ p[0][0] = cx - s * 0.5f, p[0][1] = cy - s, p[1][0] = cx - s * 0.5f, p[1][1] = cy + s;+ p[2][0] = cx + s * 0.7f, p[2][1] = cy;+ break;+ }+ BUI_raster_polygon(bk_draw.r, (const float(*)[2])p, 3, c);+}++static void wd_draw(const BKWidgetDraw *w)+{+ BKRect r = wd_rect(w->rect);+ const int ws = w->state;+ int st = ws_state(ws);+ const int corners = w->corners;+ const bool enabled = !(ws & BK_WS_DISABLED);+ BKWCol wc;+ switch (w->kind) {+ case BK_WIDGET_BUTTON:+ case BK_WIDGET_TOGGLE:+ case BK_WIDGET_ARROW: { /* button_draw, toggle_draw */+ bk_widget_state(&wc, w->kind == BK_WIDGET_TOGGLE ? &bk_theme.toggle : &bk_theme.regular,+ st);+ bk_widget_but(&wc, &r, st, corners); /* flat: nothing unless hovered */+ const uchar *tc = (st & ST_NO_EMBOSS) ? bk_theme.text : wc.text;+ if (w->kind == BK_WIDGET_ARROW) {+ float c[4];+ bk_rgba(tc, c);+ wd_triangle(r.xmin + bk_rw(&r) * 0.5f, r.ymin + bk_rh(&r) * 0.5f, (int)w->value,+ 0.2f * BK_MIN(bk_rw(&r), bk_rh(&r)) + 0.5f, c);+ }+ else {+ wd_text_in(&r, w->text, tc, w->align < 0 ? BK_ALIGN_CENTER : w->align);+ }+ break;+ }+ case BK_WIDGET_CHECKBOX: { /* checkbox_draw */+ bk_widget_state(&wc, &bk_theme.option, st);+ bk_widget_optionbut(&wc, &r, st);+ uchar tc[4];+ memcpy(tc, wc.text, 4);+ if (!enabled) {+ tc[3] /= 2;+ }+ bk_text_in_pad(&r, w->text, tc, BK_ALIGN_LEFT, false, 0);+ break;+ }+ case BK_WIDGET_RADIO: { /* widget_optionbut, with a round box and a dot */+ bk_widget_state(&wc, &bk_theme.option, st);+ BKRect rt = r;+ rt.xmax = rt.xmin + bk_rh(&rt);+ const int delta = (int)((bk_rh(&rt) - 2 * bk_px()) / 6);+ rt.ymin += delta;+ rt.ymax -= delta;+ rt.xmax -= 2 * delta;+ WidgetBase wtb;+ widget_init(&wtb);+ round_box_edges(&wtb, CNR_ALL, &rt, 0.5f * bk_rh(&rt));+ widgetbase_draw(&wtb, &wc);+ if (st & ST_SELECT) {+ float c[4];+ bk_rgba(wc.item, c);+ bk_circle(rt.xmin + bk_rw(&rt) * 0.5f, rt.ymin + bk_rh(&rt) * 0.5f, bk_rh(&rt) * 0.2f,+ c);+ }+ r.xmin = rt.xmax + (int)(delta * 0.9f);+ uchar tc[4];+ memcpy(tc, wc.text, 4);+ if (!enabled) {+ tc[3] /= 2;+ }+ bk_text_in_pad(&r, w->text, tc, BK_ALIGN_LEFT, false, 0);+ break;+ }+ case BK_WIDGET_NUMBER:+ case BK_WIDGET_SLIDER:+ if (ws & BK_WS_EDITING) { /* draw_editing: the toolkit draws the text */+ bk_widget_state(&wc, &bk_theme.textfield, ST_SELECT | ST_TEXT_INPUT);+ bk_widget_textbut(&wc, &r, ST_SELECT, corners);+ break;+ }+ if (w->kind == BK_WIDGET_NUMBER) { /* number_draw */+ bk_widget_state(&wc, &bk_theme.num, st);+ bk_widget_numbut(&wc, &r, st, corners);+ }+ else { /* slider_draw */+ bk_widget_state(&wc, &bk_theme.numslider, st);+ bk_widget_numslider(&wc, &r, st, corners, w->value);+ }+ wd_number_texts(&r, w->text, w->text2, wc.text);+ break;+ case BK_WIDGET_TEXT: /* text_draw */+ if (ws & BK_WS_EDITING) {+ st = ST_SELECT | ST_TEXT_INPUT;+ }+ bk_widget_state(&wc, &bk_theme.textfield, st);+ bk_widget_textbut(&wc, &r, st, corners);+ bk_text_in(&r, w->text, wc.text, BK_ALIGN_LEFT, false);+ break;+ case BK_WIDGET_MENU: /* dropdown_draw */+ bk_widget_state(&wc, &bk_theme.menu, st);+ bk_widget_menubut(&wc, &r, st, corners);+ wd_text_in(&r, w->text, wc.text, w->align < 0 ? BK_ALIGN_LEFT : w->align);+ break;+ case BK_WIDGET_PULLDOWN:+ bk_widget_state(&wc, &bk_theme.pulldown, st & ~ST_SELECT);+ bk_widget_pulldownbut(&wc, &r, (st & ST_SELECT) ? ST_HOVER : st, corners);+ wd_text_at(w, &r, w->text, wc.text, w->align < 0 ? BK_ALIGN_CENTER : w->align);+ break;+ case BK_WIDGET_MENU_ITEM: { /* menu_draw, one row */+ const BKWCol *mi = &bk_theme.menu_item;+ int mst = enabled ? 0 : ST_DISABLED;+ if (ws & BK_WS_HOVER) {+ mst |= ST_HOVER;+ }+ if (ws & (BK_WS_SELECTED | BK_WS_PRESSED)) {+ mst |= ST_ACTIVE_DEFAULT;+ }+ bk_widget_state_menu_item(&wc, mi, mst);+ BKRect wr = r;+ if (mst & (ST_HOVER | ST_ACTIVE_DEFAULT)) {+ bk_widget_menu_itembut(&wc, &wr);+ }+ const int check = (int)w->value;+ if (check == 1 || check == 2) { /* menu_check_icon */+ const int s = bk_iround(0.6f * bk_unit());+ BKRect cr = bk_rect((int)(w->aux[0] - s * 0.5f), (int)(w->aux[1] - s * 0.5f), s, s);+ BKWCol oc;+ bk_widget_state(&oc, &bk_theme.option, check == 2 ? ST_SELECT : 0);+ bk_widget_optionbut(&oc, &cr, check == 2 ? ST_SELECT : 0);+ }+ bk_clip_push(r.xmin, r.ymin, bk_rw(&r), bk_rh(&r));+ wd_text_at(w, &r, w->text, wc.text, BK_ALIGN_LEFT);+ if (w->text2 && w->text2[0]) {+ uchar sc[4];+ memcpy(sc, wc.text, 4);+ sc[3] = (uchar)(sc[3] * 0.55f);+ const float sw = bk_text_width(w->text2, -1, false);+ const float right = w->text_rect[2] > 0 ? w->text_rect[0] + w->text_rect[2] :+ (float)(r.xmax - bk_pad());+ bk_text(right - sw, bk_text_baseline(&r), w->text2, -1, sc, false);+ }+ bk_clip_pop();+ if (check == 3) {+ uchar ac[4];+ memcpy(ac, wc.text, 4);+ ac[3] = (uchar)(ac[3] * 0.8f);+ bk_icon(bk_icons_lookup("RIGHTARROW"), r.xmax - 0.5f * bk_unit(),+ r.ymin + bk_rh(&r) * 0.5f, ac, 1.0f, 0.6f * bk_unit());+ }+ break;+ }+ case BK_WIDGET_LIST_ITEM: { /* list rows (kit_views.c) */+ bk_widget_state(&wc, &bk_theme.list_item, st & ST_SELECT);+ BKRect wr = r;+ bk_widget_list_itembut(&wc, &wr, st & (ST_SELECT | ST_HOVER));+ uchar tc[4];+ memcpy(tc, (st & ST_SELECT) ? bk_theme.list_item.text_sel : bk_theme.list_item.text, 4);+ if (!enabled) {+ tc[3] /= 2;+ }+ wd_text_at(w, &r, w->text, tc, w->align);+ break;+ }+ case BK_WIDGET_DISCLOSURE: { /* tree_draw_row */+ if (st & (ST_HOVER | ST_SELECT)) {+ bk_widget_state(&wc, &bk_theme.list_item, st & ST_SELECT);+ BKRect wr = r;+ bk_widget_list_itembut(&wc, &wr, st & (ST_SELECT | ST_HOVER));+ }+ uchar tc[4];+ memcpy(tc, (st & ST_SELECT) ? bk_theme.list_item.text_sel : bk_theme.text, 4);+ if (!enabled) {+ tc[3] /= 2;+ }+ if (w->aux[0] > 0.0f) {+ bk_icon(bk_icons_lookup((ws & BK_WS_OPEN) ? "DISCLOSURE_TRI_DOWN" : "DISCLOSURE_TRI_RIGHT"),+ w->aux[0], r.ymin + bk_rh(&r) * 0.5f, tc, 0.8f, 0);+ }+ wd_text_at(w, &r, w->text, tc, BK_ALIGN_LEFT);+ break;+ }+ case BK_WIDGET_SWATCH: { /* swatch_draw */+ bk_widget_state(&wc, &bk_theme.regular, st & ~ST_SELECT);+ const float opaque[4] = {w->color[0], w->color[1], w->color[2], 1.0f};+ BKRect rr = r;+ bk_widget_swatch(&wc, &rr, st & ~ST_SELECT, corners, opaque);+ if (w->color[3] < 1.0f) {+ rr = r;+ bk_clip_push(r.xmin + bk_rw(&r) / 2, r.ymin - 2, bk_rw(&r), bk_rh(&r) + 4);+ bk_widget_swatch(&wc, &rr, st & ~ST_SELECT, corners, w->color);+ bk_clip_pop();+ }+ break;+ }+ case BK_WIDGET_PROGRESS: /* progress_draw */+ bk_widget_state(&wc, &bk_theme.progress, enabled ? 0 : ST_DISABLED);+ bk_widget_progress(&wc, &r, corners, w->value);+ bk_text_in(&r, w->text, wc.text, BK_ALIGN_CENTER, false);+ break;+ case BK_WIDGET_TAB: { /* tabs_draw, one tab */+ const bool active = (ws & BK_WS_SELECTED) != 0;+ float c[4];+ BKWCol tw = bk_theme.tab;+ if (!active && (ws & BK_WS_HOVER)) {+ bk_widget_active_color(&tw);+ }+ bk_rgba(active ? tw.inner_sel : tw.inner, c);+ bk_roundbox((float)r.xmin, (float)r.ymin, (float)bk_rw(&r), (float)bk_rh(&r),+ bk_widget_radius(&bk_theme.tab), corners, c);+ uchar tc[4];+ memcpy(tc, active ? tw.text_sel : tw.text, 4);+ if (!enabled) {+ tc[3] /= 2;+ }+ if (w->text_rect[2] > 0.0f) {+ const BKRect tr = wd_rect(w->text_rect);+ bk_text_in_pad(&tr, w->text, tc, w->align < 0 ? BK_ALIGN_CENTER : w->align, false, 0);+ }+ else {+ bk_text_in(&r, w->text, tc, BK_ALIGN_CENTER, false);+ }+ break;+ }+ case BK_WIDGET_PANEL_HEADER: { /* panel_draw: the header of a top-level panel */+ const int hh = bk_rh(&r);+ const float uu = (float)bk_unit();+ const bool open = (ws & BK_WS_OPEN) != 0;+ const float rad = bk_theme.panel_roundness * 0.5f * uu;+ float c[4];+ BKWCol hc = bk_theme.regular;+ memcpy(hc.inner, bk_theme.panel_header, 4);+ if (st & ST_HOVER) {+ bk_widget_active_color(&hc);+ }+ bk_rgba(hc.inner, c);+ bk_roundbox((float)r.xmin, (float)r.ymin, (float)bk_rw(&r), (float)hh, rad, corners, c);+ const float isz = (float)bk_icon_size();+ const float icy = r.ymin + hh - hh * (open ? 0.14f : 0.17f) - isz * 0.5f;+ if (!(ws & BK_WS_FLAT)) { /* FLAT: no arrow (a leaf) */+ bk_icon(bk_icons_lookup(open ? "DOWNARROW_HLT" : "RIGHTARROW"),+ r.xmin + hh * 0.2f + isz * 0.5f, icy, bk_theme.text, enabled ? 0.8f : 0.4f, 0);+ }+ BKRect tr = {r.xmin + (int)(1.1f * uu) - bk_pad(), r.ymin, r.xmax, r.ymax + 2};+ if (w->text_rect[2] > 0.0f) {+ tr.xmax = bk_iround(w->text_rect[0] + w->text_rect[2]);+ }+ const int shadow = bk_text_shadow;+ bk_text_shadow = 3;+ uchar tc[4];+ memcpy(tc, bk_theme.text, 4);+ if (!enabled) {+ tc[3] /= 2;+ }+ bk_text_in(&tr, w->text, tc, BK_ALIGN_LEFT, false);+ bk_text_shadow = shadow;+ bk_rgba(bk_theme.panel_outline, c);+ if (c[3] > 0.0f) {+ BuiWidgetBase wb = {+ {(float)r.xmin, (float)r.ymin, (float)bk_rw(&r), (float)hh}, rad, rad - 1, corners};+ memcpy(wb.outline, c, sizeof(c));+ wb.pixelsize = 1.0f;+ BUI_raster_widget_base(bk_draw.r, &wb);+ }+ break;+ }+ case BK_WIDGET_MENU_BACK:+ bk_widget_menu_back(&r, corners);+ break;+ case BK_WIDGET_TOOLTIP_BACK:+ bk_widget_tooltip_back(&r);+ break;+ case BK_WIDGET_BOX:+ bk_widget_box(&bk_theme.box, &r, corners, NULL);+ break;+ case BK_WIDGET_SEPARATOR: {+ float c[4];+ bk_rgba_alpha(bk_theme.text, 0.15f * (enabled ? 1.0f : 0.5f), c);+ if (bk_rh(&r) > bk_rw(&r)) {+ bk_fill_f(r.xmin + bk_rw(&r) / 2, r.ymin, 1, bk_rh(&r), c);+ }+ else {+ bk_fill_f(r.xmin, r.ymin + bk_rh(&r) / 2, bk_rw(&r), 1, c);+ }+ break;+ }+ case BK_WIDGET_LABEL: {+ uchar tc[4];+ if (w->color[3] >= 0.0f) {+ for (int k = 0; k < 4; k++) {+ tc[k] = (uchar)BK_CLAMP(w->color[k] * 255.0f + 0.5f, 0.0f, 255.0f);+ }+ }+ else {+ memcpy(tc, bk_theme.text, 4);+ if (!enabled) {+ tc[3] /= 2;+ }+ }+ wd_text_at(w, &r, w->text, tc, w->align < 0 ? BK_ALIGN_LEFT : w->align);+ break;+ }+ default:+ break;+ }+}++void BK_draw_widget(BuiRaster *r, const BKWidgetDraw *w)+{+ if (!r || !w) {+ return;+ }+ const BKDraw saved = bk_draw;+ const bool own = bk_draw.r != r;+ if (own) { /* outside a BK_render: the whole raster */+ bk_draw.r = r;+ bk_clip_reset(BUI_raster_width(r), BUI_raster_height(r));+ }+ const bool clip = w->clip[2] > w->clip[0];+ if (clip) {+ const int x0 = (int)floorf(w->clip[0]), y0 = (int)floorf(w->clip[1]);+ bk_clip_push(x0, y0, (int)ceilf(w->clip[2]) - x0, (int)ceilf(w->clip[3]) - y0);+ }+ if (bk_draw.clip[2] > bk_draw.clip[0] && bk_draw.clip[3] > bk_draw.clip[1]) {+ wd_draw(w);+ }+ if (clip) {+ bk_clip_pop();+ }+ if (own) {+ bk_draw = saved;+ if (bk_draw.r) {+ clip_apply();+ }+ }+}++/** \} */