Use backend buttons in Preferences UI

Replace the renderer-backend dropdown with a row of per-backend buttons in the Preferences window, including disabled styling for unavailable backends, synthetic layout items/rects for testing, and a small "Reset to Auto" button. Validate requested backend, show stored/current/next-launch info, and reset invalid selections to Auto when the window closes. Remove the unused backend_combo_label helper. Also remove DockNodeFlags_NoDockingSplit from the image window class. Update the backend preferences regression tool to locate backend button rects and centers (rename helpers and parameters) and to emit clicks against the new button-based UI.

Author: ssh4net

src/imiv/imiv_aux_windows.cpp

@@ -118,14 +118,6 @@ namespace {
         ImGui::PopTextWrapPos();
     }
 
-    std::string backend_combo_label(const BackendInfo& info)
-    {
-        std::string label = std::string(backend_display_name(info.kind));
-        if (!info.compiled)
-            label += " (not built)";
-        return label;
-    }
-
     bool input_text_string(const char* label, std::string& value)
     {
         char buffer[4096];
@@ -277,52 +269,85 @@ draw_preferences_window(PlaceholderUiState& ui, bool& show_window,
         ImGui::Checkbox("Generate mipmaps (requires restart)", &ui.auto_mipmap);
 
         ImGui::Spacing();
-        const BackendKind requested_backend = sanitize_backend_kind(
+        BackendKind requested_backend = sanitize_backend_kind(
             ui.renderer_backend);
+        const float spacing = ImGui::GetStyle().ItemSpacing.x;
+        const float row_width = ImGui::GetContentRegionAvail().x;
+        const float button_width = std::max(
+            1.0f, (row_width - spacing * 2.0f) / 3.0f);
+        bool have_backend_row_rect = false;
+        ImVec2 backend_row_min(0.0f, 0.0f);
+        ImVec2 backend_row_max(0.0f, 0.0f);
+        int backend_button_index = 0;
+        for (const BackendInfo& info : compiled_backend_info()) {
+            const bool selected = requested_backend == info.kind;
+            if (backend_button_index > 0)
+                ImGui::SameLine(0.0f, spacing);
+            ImGui::PushID(static_cast<int>(info.kind));
+            if (!info.compiled)
+                ImGui::BeginDisabled();
+            push_preview_active_button_style(selected);
+            if (ImGui::Button(backend_display_name(info.kind),
+                              ImVec2(button_width, 0.0f))
+                && info.compiled) {
+                ui.renderer_backend = static_cast<int>(info.kind);
+            }
+            pop_preview_active_button_style(selected);
+            if (!info.compiled)
+                ImGui::EndDisabled();
+            register_layout_dump_synthetic_item("button",
+                                                backend_display_name(info.kind));
+            const ImVec2 item_min = ImGui::GetItemRectMin();
+            const ImVec2 item_max = ImGui::GetItemRectMax();
+            if (!have_backend_row_rect) {
+                backend_row_min       = item_min;
+                backend_row_max       = item_max;
+                have_backend_row_rect = true;
+            } else {
+                backend_row_min.x = std::min(backend_row_min.x, item_min.x);
+                backend_row_min.y = std::min(backend_row_min.y, item_min.y);
+                backend_row_max.x = std::max(backend_row_max.x, item_max.x);
+                backend_row_max.y = std::max(backend_row_max.y, item_max.y);
+            }
+            ImGui::PopID();
+            ++backend_button_index;
+        }
+        if (have_backend_row_rect) {
+            register_layout_dump_synthetic_rect("button", "Renderer backend",
+                                                backend_row_min,
+                                                backend_row_max);
+        }
+
+        requested_backend = sanitize_backend_kind(ui.renderer_backend);
         const BackendKind next_launch_backend = resolve_backend_request(
             requested_backend);
         const bool requested_backend_compiled
             = requested_backend == BackendKind::Auto
               || backend_kind_is_compiled(requested_backend);
-        std::string backend_label
-            = std::string(backend_display_name(requested_backend));
-        if (requested_backend != BackendKind::Auto
-            && !requested_backend_compiled) {
-            backend_label += " (not built)";
-        }
-        if (ImGui::BeginCombo("Renderer backend", backend_label.c_str())) {
-            register_test_engine_item_label("Renderer backend", true);
-            const bool auto_selected = requested_backend == BackendKind::Auto;
-            if (ImGui::Selectable("Auto", auto_selected)) {
-                ui.renderer_backend = static_cast<int>(BackendKind::Auto);
-            }
-            if (auto_selected)
-                ImGui::SetItemDefaultFocus();
-            for (const BackendInfo& info : compiled_backend_info()) {
-                const bool selected = requested_backend == info.kind;
-                const std::string label = backend_combo_label(info);
-                if (!info.compiled)
-                    ImGui::BeginDisabled();
-                if (ImGui::Selectable(label.c_str(), selected)
-                    && info.compiled) {
-                    ui.renderer_backend = static_cast<int>(info.kind);
-                }
-                if (!info.compiled)
-                    ImGui::EndDisabled();
-                if (selected)
-                    ImGui::SetItemDefaultFocus();
-            }
-            ImGui::EndCombo();
-        } else {
-            register_test_engine_item_label("Renderer backend", true);
-        }
+        const bool invalid_requested_backend = requested_backend != BackendKind::Auto
+                                              && !requested_backend_compiled;
+        if (requested_backend == BackendKind::Auto)
+            ImGui::TextUnformatted("Stored preference: Auto");
+        else
+            ImGui::Text("Stored preference: %s",
+                        backend_display_name(requested_backend));
+        ImGui::SameLine();
+        if (requested_backend == BackendKind::Auto)
+            ImGui::BeginDisabled();
+        if (ImGui::SmallButton("Reset to Auto"))
+            ui.renderer_backend = static_cast<int>(BackendKind::Auto);
+        register_layout_dump_synthetic_item("button", "Reset to Auto");
+        if (requested_backend == BackendKind::Auto)
+            ImGui::EndDisabled();
         ImGui::TextUnformatted("Current backend");
         ImGui::SameLine();
         ImGui::TextUnformatted(backend_display_name(active_backend));
-        if (requested_backend != BackendKind::Auto
-            && !requested_backend_compiled) {
+        ImGui::Text("Next launch backend: %s",
+                    backend_display_name(resolve_backend_request(
+                        sanitize_backend_kind(ui.renderer_backend))));
+        if (invalid_requested_backend) {
             ImGui::TextUnformatted(
-                "Requested backend is not built into this binary.");
+                "Requested backend is not built in this binary and will be ignored when Preferences closes.");
         } else if (next_launch_backend != active_backend) {
             ImGui::TextUnformatted("Backend change requires restart.");
         }
@@ -422,6 +447,11 @@ draw_preferences_window(PlaceholderUiState& ui, bool& show_window,
     }
     ImGui::End();
     ImGui::PopStyleVar();
+    const BackendKind close_backend = sanitize_backend_kind(ui.renderer_backend);
+    if (!show_window && close_backend != BackendKind::Auto
+        && !backend_kind_is_compiled(close_backend)) {
+        ui.renderer_backend = static_cast<int>(BackendKind::Auto);
+    }
 }
 
 void

src/imiv/imiv_frame.cpp

@@ -501,8 +501,7 @@ setup_image_window_policy(ImGuiID dockspace_id, bool force_dock)
 
     ImGuiWindowClass window_class;
     window_class.ClassId                  = ImGui::GetID("imiv.image.window");
-    window_class.DockNodeFlagsOverrideSet = ImGuiDockNodeFlags_NoDockingSplit
-                                            | ImGuiDockNodeFlags_AutoHideTabBar;
+    window_class.DockNodeFlagsOverrideSet = ImGuiDockNodeFlags_AutoHideTabBar;
     ImGui::SetNextWindowClass(&window_class);
 }
 

src/imiv/tools/imiv_backend_preferences_regression.py

@@ -97,8 +97,7 @@ def _write_scenario(
     path: Path,
     runtime_dir_rel: str,
     *,
-    combo_center: tuple[float, float],
-    choice_points: dict[str, tuple[float, float]],
+    button_points: dict[str, tuple[float, float]],
 ) -> None:
     root = ET.Element("imiv-scenario")
     root.set("out_dir", runtime_dir_rel)
@@ -110,47 +109,26 @@ def _write_scenario(
         state=True,
         post_action_delay_frames=2,
     )
-    _scenario_step(
-        root,
-        "open_alternate_backend_combo",
-        mouse_pos=f"{combo_center[0]:.3f},{combo_center[1]:.3f}",
-        mouse_click_button=0,
-        post_action_delay_frames=1,
-    )
     _scenario_step(
         root,
         "select_alternate_backend",
-        mouse_pos=f"{choice_points['alternate'][0]:.3f},{choice_points['alternate'][1]:.3f}",
+        mouse_pos=f"{button_points['alternate'][0]:.3f},{button_points['alternate'][1]:.3f}",
         mouse_click_button=0,
         state=True,
         post_action_delay_frames=2,
     )
-    _scenario_step(
-        root,
-        "open_active_backend_combo",
-        mouse_pos=f"{combo_center[0]:.3f},{combo_center[1]:.3f}",
-        mouse_click_button=0,
-        post_action_delay_frames=1,
-    )
     _scenario_step(
         root,
         "select_active_backend",
-        mouse_pos=f"{choice_points['active'][0]:.3f},{choice_points['active'][1]:.3f}",
+        mouse_pos=f"{button_points['active'][0]:.3f},{button_points['active'][1]:.3f}",
         mouse_click_button=0,
         state=True,
         post_action_delay_frames=2,
     )
-    _scenario_step(
-        root,
-        "open_auto_backend_combo",
-        mouse_pos=f"{combo_center[0]:.3f},{combo_center[1]:.3f}",
-        mouse_click_button=0,
-        post_action_delay_frames=1,
-    )
     _scenario_step(
         root,
         "select_auto_backend",
-        mouse_pos=f"{choice_points['auto'][0]:.3f},{choice_points['auto'][1]:.3f}",
+        mouse_pos=f"{button_points['auto'][0]:.3f},{button_points['auto'][1]:.3f}",
         mouse_click_button=0,
         state=True,
         post_action_delay_frames=2,
@@ -184,7 +162,7 @@ def _load_state(path: Path) -> dict:
     return json.loads(path.read_text(encoding="utf-8"))
 
 
-def _find_combo_rect(layout: dict, label: str) -> dict:
+def _find_item_rect(layout: dict, label: str) -> dict:
     for window in layout.get("windows", []):
         if window.get("name") != "iv Preferences":
             continue
@@ -205,26 +183,17 @@ def _rect_center(rect: dict) -> tuple[float, float]:
     )
 
 
-def _backend_popup_choice_points(
-    combo_rect: dict, *, alternate_backend: str, active_backend: str
+def _backend_button_points(
+    layout: dict, *, alternate_backend: str, active_backend: str
 ) -> dict[str, tuple[float, float]]:
-    order = {"auto": 0, "vulkan": 1, "metal": 2, "opengl": 3}
-    rect_min = combo_rect.get("min", [0.0, 0.0])
-    rect_max = combo_rect.get("max", [0.0, 0.0])
-    min_x = float(rect_min[0])
-    min_y = float(rect_min[1])
-    max_x = float(rect_max[0])
-    max_y = float(rect_max[1])
-    row_h = max(1.0, max_y - min_y)
-    choice_x = min_x + max(24.0, (max_x - min_x) * 0.35)
-
-    def _point(name: str) -> tuple[float, float]:
-        return (choice_x, max_y + row_h * (order[name] + 0.5))
-
     return {
-        "alternate": _point(alternate_backend),
-        "active": _point(active_backend),
-        "auto": _point("auto"),
+        "alternate": _rect_center(
+            _find_item_rect(layout, _backend_display_name(alternate_backend))
+        ),
+        "active": _rect_center(
+            _find_item_rect(layout, _backend_display_name(active_backend))
+        ),
+        "auto": _rect_center(_find_item_rect(layout, "Reset to Auto")),
     }
 
 
@@ -380,10 +349,8 @@ def main() -> int:
         return _fail(f"probe runner exited with code {probe_proc.returncode}")
 
     probe_layout = json.loads(probe_layout_path.read_text(encoding="utf-8"))
-    combo_rect = _find_combo_rect(probe_layout, "Renderer backend")
-    combo_center = _rect_center(combo_rect)
-    choice_points = _backend_popup_choice_points(
-        combo_rect,
+    button_points = _backend_button_points(
+        probe_layout,
         alternate_backend=alternate_backend,
         active_backend=active_backend,
     )
@@ -392,8 +359,7 @@ def main() -> int:
     _write_scenario(
         scenario_path,
         runtime_dir_rel,
-        combo_center=combo_center,
-        choice_points=choice_points,
+        button_points=button_points,
     )
 
     cmd = [