window_sidebar.cc

Go to the documentation of this file.

#include "app/editor/menu/window_sidebar.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <cctype>
#include <map>
#include <string>
#include <vector>
 
#include "absl/strings/str_format.h"
#include "app/editor/system/session/user_settings.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/core/ui_config.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/themed_widgets.h"
#include "core/color.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace editor {
 
namespace {
 
std::string LowercaseCopy(std::string value) {
  std::transform(
      value.begin(), value.end(), value.begin(),
      [](unsigned char c) { return static_cast<char>(::tolower(c)); });
  return value;
}
 
bool MatchesWindowSearch(const std::string& query,
                         const WindowDescriptor& window) {
  return WindowSidebar::MatchesWindowSearch(
      query, window.display_name, window.card_id, window.shortcut_hint);
}
 
bool IsDungeonRoomWindow(const std::string& window_id) {
  constexpr char kPrefix[] = "dungeon.room_";
  constexpr size_t kPrefixLength = sizeof(kPrefix) - 1;
  if (window_id.rfind(kPrefix, 0) != 0 || window_id.size() <= kPrefixLength) {
    return false;
  }
  // DungeonEditorV2 registers dynamic room windows with a decimal room number.
  // Other room_* IDs, such as room_graphics and room_tags, are standalone tools.
  return std::all_of(window_id.begin() + kPrefixLength, window_id.end(),
                     [](char ch) { return ch >= '0' && ch <= '9'; });
}
 
bool IsDungeonPanelModeWindow(const std::string& window_id) {
  return WindowSidebar::IsDungeonWindowModeTarget(window_id);
}
 
}  // namespace
 
WindowSidebar::WindowSidebar(
    WorkspaceWindowManager& window_manager,
    std::function<bool()> is_dungeon_workbench_mode,
    std::function<void(bool)> set_dungeon_workflow_mode,
    std::function<float()> get_bottom_reserved_height,
    std::function<EditorContextSnapshot(const std::string&)> context_provider)
    : window_manager_(window_manager),
      is_dungeon_workbench_mode_(std::move(is_dungeon_workbench_mode)),
      set_dungeon_workflow_mode_(std::move(set_dungeon_workflow_mode)),
      get_bottom_reserved_height_(std::move(get_bottom_reserved_height)),
      context_provider_(std::move(context_provider)) {}
 
bool WindowSidebar::HasRenderableContext(
    const EditorContextSnapshot& snapshot) {
  return !snapshot.subtitle.empty() || !snapshot.metadata.empty() ||
         !snapshot.counts.empty() || !snapshot.diagnostics.empty() ||
         !snapshot.actions.empty() || snapshot.has_pending_changes ||
         snapshot.experiment.experimental;
}
 
void WindowSidebar::DispatchContextAction(size_t session_id,
                                          const EditorContextAction& action) {
  if (!action.enabled || action.target.empty()) {
    return;
  }
  if (action.kind != EditorContextActionKind::kOpenWindow) {
    return;
  }
  if (!window_manager_.OpenWindow(session_id, action.target)) {
    return;
  }
  window_manager_.MarkWindowRecentlyUsed(action.target);
  if (const auto* descriptor =
          window_manager_.GetWindowDescriptor(session_id, action.target)) {
    window_manager_.TriggerWindowClicked(descriptor->category);
    const std::string window_name =
        window_manager_.GetWorkspaceWindowName(*descriptor);
    if (!window_name.empty()) {
      ImGui::SetWindowFocus(window_name.c_str());
    }
  }
}
 
void WindowSidebar::DrawEditorContext(size_t session_id,
                                      const std::string& category,
                                      const EditorContextSnapshot& snapshot) {
  if (!HasRenderableContext(snapshot)) {
    return;
  }
 
  ImGui::PushID(category.c_str());
  ImGui::SeparatorText(tr("Context"));
  if (!snapshot.title.empty())
    ImGui::TextWrapped("%s", snapshot.title.c_str());
  if (snapshot.experiment.experimental) {
    const std::string label =
        "Experimental · " + snapshot.experiment.save_posture;
    gui::ColoredText(label.c_str(), gui::GetWarningVec4());
  }
  if (snapshot.has_pending_changes)
    gui::ColoredText(snapshot.pending_label.empty()
                         ? "Pending changes"
                         : snapshot.pending_label.c_str(),
                     gui::GetWarningVec4());
  for (const auto& diagnostic : snapshot.diagnostics) {
    if (diagnostic.severity == EditorContextDiagnosticSeverity::kInfo)
      continue;
    ImGui::TextWrapped("%s", diagnostic.message.c_str());
  }
  if (ImGui::Button(tr("Context details")))
    context_details_category_ = category;
  ImGui::PopID();
}
 
void WindowSidebar::DrawContextDetailsWindow(size_t session_id) {
  if (context_details_category_.empty())
    return;
  const EditorContextSnapshot snapshot =
      context_provider_ ? context_provider_(context_details_category_)
                        : EditorContextSnapshot{};
  if (!HasRenderableContext(snapshot)) {
    context_details_category_.clear();
    return;
  }
  bool open = true;
  ImGui::SetNextWindowSize(ImVec2(520, 480), ImGuiCond_FirstUseEver);
  const std::string title =
      context_details_category_ + " Context###EditorContextDetails";
  if (ImGui::Begin(title.c_str(), &open))
    DrawEditorContextDetails(session_id, snapshot);
  ImGui::End();
  if (!open)
    context_details_category_.clear();
}
 
void WindowSidebar::DrawEditorContextDetails(
    size_t session_id, const EditorContextSnapshot& snapshot) {
  if (!snapshot.title.empty()) {
    ImGui::TextWrapped("%s", snapshot.title.c_str());
  }
  if (!snapshot.subtitle.empty()) {
    ImGui::TextDisabled("%s", snapshot.subtitle.c_str());
  }
  if (snapshot.experiment.experimental) {
    const std::string experiment_label =
        absl::StrFormat("Experimental · %s", snapshot.experiment.save_posture);
    gui::ColoredText(experiment_label.c_str(), snapshot.experiment.acknowledged
                                                   ? gui::GetTextSecondaryVec4()
                                                   : gui::GetWarningVec4());
  }
  if (snapshot.has_pending_changes) {
    gui::ColoredText(snapshot.pending_label.empty()
                         ? ICON_MD_EDIT " Pending changes"
                         : snapshot.pending_label.c_str(),
                     gui::GetWarningVec4());
  }
 
  const auto draw_values = [](const char* table_id,
                              const std::vector<EditorContextValue>& values) {
    if (values.empty()) {
      return;
    }
    if (ImGui::BeginTable(
            table_id, 2,
            ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_PadOuterX)) {
      ImGui::TableSetupColumn("Label", ImGuiTableColumnFlags_WidthFixed);
      ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
      for (const EditorContextValue& value : values) {
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
        ImGui::TextDisabled("%s", value.label.c_str());
        ImGui::TableNextColumn();
        ImGui::TextWrapped("%s", value.value.c_str());
      }
      ImGui::EndTable();
    }
  };
 
  if (!snapshot.metadata.empty()) {
    ImGui::SeparatorText(tr("Metadata"));
    draw_values("##ContextMetadata", snapshot.metadata);
  }
  if (!snapshot.counts.empty()) {
    ImGui::SeparatorText(tr("Contents"));
    draw_values("##ContextCounts", snapshot.counts);
  }
 
  if (!snapshot.diagnostics.empty()) {
    ImGui::SeparatorText(tr("Attention"));
    ImGui::PushTextWrapPos(0.0f);
    for (const EditorContextDiagnostic& diagnostic : snapshot.diagnostics) {
      switch (diagnostic.severity) {
        case EditorContextDiagnosticSeverity::kError:
          gui::ColoredTextF(gui::GetErrorVec4(), "%s %s", ICON_MD_ERROR,
                            diagnostic.message.c_str());
          break;
        case EditorContextDiagnosticSeverity::kWarning:
          gui::ColoredTextF(gui::GetWarningVec4(), "%s %s", ICON_MD_WARNING,
                            diagnostic.message.c_str());
          break;
        case EditorContextDiagnosticSeverity::kInfo:
        default:
          gui::ColoredTextF(gui::GetTextSecondaryVec4(), "%s %s", ICON_MD_INFO,
                            diagnostic.message.c_str());
          break;
      }
    }
    ImGui::PopTextWrapPos();
  }
 
  if (!snapshot.actions.empty()) {
    ImGui::SeparatorText(tr("Quick Actions"));
    for (const EditorContextAction& action : snapshot.actions) {
      ImGui::PushID(action.id.c_str());
      ImGui::BeginDisabled(!action.enabled);
      if (ImGui::Button(action.label.c_str(), ImVec2(-1.0f, 0.0f))) {
        DispatchContextAction(session_id, action);
      }
      if (!action.enabled && !action.disabled_reason.empty() &&
          ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
        ImGui::SetTooltip("%s", action.disabled_reason.c_str());
      }
      ImGui::EndDisabled();
      ImGui::PopID();
    }
  }
}
 
bool WindowSidebar::MatchesWindowSearch(const std::string& query,
                                        const std::string& display_name,
                                        const std::string& window_id,
                                        const std::string& shortcut_hint) {
  if (query.empty()) {
    return true;
  }
 
  const std::string search_str = LowercaseCopy(query);
  return LowercaseCopy(display_name).find(search_str) != std::string::npos ||
         LowercaseCopy(window_id).find(search_str) != std::string::npos ||
         LowercaseCopy(shortcut_hint).find(search_str) != std::string::npos;
}
 
bool WindowSidebar::IsDungeonWindowModeTarget(const std::string& window_id) {
  return window_id == "dungeon.room_selector" ||
         window_id == "dungeon.room_matrix" ||
         window_id == "dungeon.entrance_list" ||
         window_id == "dungeon.entrance_properties" ||
         IsDungeonRoomWindow(window_id);
}
 
std::string WindowSidebar::SidebarSectionFor(
    const std::string& workflow_group) {
  if (workflow_group.empty() || workflow_group == "Windows") {
    return "Editors";
  }
  return workflow_group;
}
 
std::string WindowSidebar::SidebarSectionFor(const WindowDescriptor& window) {
  if (!window.workflow_group.empty() && window.workflow_group != "Windows") {
    return window.workflow_group;
  }
  // Dynamic per-room windows may omit workflow_group at registration time.
  if (IsDungeonRoomWindow(window.card_id)) {
    return "Rooms";
  }
  return SidebarSectionFor(window.workflow_group);
}
 
bool WindowSidebar::ShouldOmitWindowInSidebar(const std::string& window_id,
                                              bool dungeon_workbench_mode) {
  return dungeon_workbench_mode && IsDungeonWindowModeTarget(window_id);
}
 
void WindowSidebar::Draw(size_t session_id, const std::string& category,
                         std::function<bool()> has_rom) {
  const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
  const float bar_width = WorkspaceWindowManager::GetSidebarWidth();
  const float panel_width =
      window_manager_.GetActiveSidePanelWidth(viewport->WorkSize.x);
 
  const float top_inset = gui::LayoutHelpers::GetTopInset();
  const auto safe_area = gui::LayoutHelpers::GetSafeAreaInsets();
  const float bottom_reserved =
      get_bottom_reserved_height_
          ? std::max(0.0f, get_bottom_reserved_height_())
          : 0.0f;
  const float panel_height =
      std::max(0.0f, viewport->WorkSize.y - top_inset - safe_area.bottom -
                         bottom_reserved);
 
  gui::FixedPanel panel(
      "##SidePanel",
      ImVec2(viewport->WorkPos.x + bar_width, viewport->WorkPos.y + top_inset),
      ImVec2(panel_width, panel_height),
      {.bg = gui::ConvertColorToImVec4(theme.surface),
       .padding = {10.0f, 10.0f},
       .border_size = 1.0f,
       .rounding = 0.0f},
      ImGuiWindowFlags_NoFocusOnAppearing);
 
  if (!panel) {
    return;
  }
 
  ImGui::PushFont(ImGui::GetIO().Fonts->Fonts[0]);
  ImGui::Text("%s", category.c_str());
  ImGui::PopFont();
 
  float avail_width = ImGui::GetContentRegionAvail().x;
  const ImVec2 chrome_icon_size = gui::IconSize::Small();
  ImGui::SameLine(ImGui::GetCursorPosX() + avail_width - chrome_icon_size.x);
  if (gui::TransparentIconButton(ICON_MD_CHEVRON_LEFT, chrome_icon_size,
                                 "Collapse Sidebar", false, ImVec4(0, 0, 0, 0),
                                 "window_sidebar", "collapse_side_panel")) {
    window_manager_.SetSidebarExpanded(false);
  }
 
  ImGui::Separator();
  ImGui::Spacing();
 
  const ImVec2 search_button_size = gui::IconSize::Small();
  const float standard_spacing =
      std::clamp(gui::LayoutHelpers::GetStandardSpacing(), 4.0f, 8.0f);
  const float compact_spacing = std::max(4.0f, standard_spacing * 0.75f);
  const float search_spacing = compact_spacing;
 
  auto read_dungeon_workbench_mode = [&]() -> bool {
    if (category != "Dungeon") {
      return false;
    }
    if (is_dungeon_workbench_mode_) {
      return is_dungeon_workbench_mode_();
    }
    return window_manager_.IsWindowOpen(session_id, "dungeon.workbench");
  };
  bool dungeon_workbench_mode = read_dungeon_workbench_mode();
  const bool rom_loaded = has_rom ? has_rom() : true;
  const bool disable_windows = !rom_loaded && category != "Emulator";
  const bool bulk_actions_enabled =
      !disable_windows && !(category == "Dungeon" && dungeon_workbench_mode);
 
  const float search_width = std::max(96.0f, ImGui::GetContentRegionAvail().x -
                                                 (search_button_size.x * 2.0f) -
                                                 (search_spacing * 2.0f));
  ImGui::SetNextItemWidth(search_width);
  ImGui::InputTextWithHint("##SidebarSearch", ICON_MD_SEARCH " Filter...",
                           sidebar_search_, sizeof(sidebar_search_));
  ImGui::SameLine(0.0f, search_spacing);
  const bool filter_empty = sidebar_search_[0] == '\0';
  if (filter_empty) {
    ImGui::BeginDisabled();
  }
  if (gui::TransparentIconButton(ICON_MD_CLEAR, search_button_size,
                                 "Clear filter", false,
                                 gui::GetTextSecondaryVec4(), "window_sidebar",
                                 "clear_sidebar_filter")) {
    sidebar_search_[0] = '\0';
  }
  if (filter_empty) {
    ImGui::EndDisabled();
  }
  ImGui::SameLine(0.0f, search_spacing);
  if (gui::TransparentIconButton(ICON_MD_MORE_HORIZ, search_button_size,
                                 "Window actions", false,
                                 gui::GetTextSecondaryVec4(), "window_sidebar",
                                 "open_sidebar_actions")) {
    ImGui::OpenPopup("##WindowSidebarActions");
  }
  if (ImGui::BeginPopup("##WindowSidebarActions")) {
    const auto category_windows =
        window_manager_.GetWindowsInCategory(session_id, category);
    int visible_windows = 0;
    int listed_windows = 0;
    for (const auto& category_window : category_windows) {
      if (!category_window.IsListedInWindowBrowser()) {
        continue;
      }
      ++listed_windows;
      if (category_window.visibility_flag && *category_window.visibility_flag) {
        ++visible_windows;
      }
    }
    ImGui::TextDisabled(tr("%d of %zu visible"), visible_windows,
                        static_cast<size_t>(listed_windows));
    ImGui::Separator();
    if (ImGui::MenuItem(ICON_MD_APPS " Window Browser")) {
      window_manager_.TriggerShowWindowBrowser();
    }
    ImGui::Separator();
    if (ImGui::MenuItem(ICON_MD_VISIBILITY " Show all", nullptr, false,
                        bulk_actions_enabled)) {
      window_manager_.ShowAllWindowsInCategory(session_id, category);
    }
    const bool show_all_hovered =
        ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled);
    if (ImGui::MenuItem(ICON_MD_VISIBILITY_OFF " Hide all", nullptr, false,
                        bulk_actions_enabled)) {
      window_manager_.HideAllWindowsInCategory(session_id, category);
    }
    const bool hide_all_hovered =
        ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled);
    if (!bulk_actions_enabled && (show_all_hovered || hide_all_hovered) &&
        category == "Dungeon" && dungeon_workbench_mode) {
      ImGui::SetTooltip(
          tr("Switch to Window workflow to bulk-manage room windows."));
    }
    ImGui::EndPopup();
  }
 
  auto switch_to_dungeon_workbench_mode = [&]() -> bool {
    if (category != "Dungeon" || dungeon_workbench_mode) {
      return false;
    }
    if (set_dungeon_workflow_mode_) {
      set_dungeon_workflow_mode_(true);
      dungeon_workbench_mode = true;
      return true;
    }
    window_manager_.OpenWindow(session_id, "dungeon.workbench");
    // Workbench-local tool windows (Object/Door/Sprite/Item Selector, Palette,
    // Room Graphics/Tags, Custom Collision, Water Fill, Minecart) are NOT
    // auto-closed here. Users can keep a standalone copy open alongside the
    // Workbench drawer's embedded copy if they prefer that layout.
    for (const auto& descriptor :
         window_manager_.GetWindowsInCategory(session_id, "Dungeon")) {
      const std::string& window_id = descriptor.card_id;
      if (window_id == "dungeon.workbench") {
        continue;
      }
      if (window_manager_.IsWindowPinned(session_id, window_id)) {
        continue;
      }
      if (IsDungeonPanelModeWindow(window_id)) {
        window_manager_.CloseWindow(session_id, window_id);
      }
    }
    dungeon_workbench_mode = read_dungeon_workbench_mode();
    return dungeon_workbench_mode;
  };
 
  auto switch_to_dungeon_window_mode = [&]() -> bool {
    if (category != "Dungeon" || !dungeon_workbench_mode) {
      return false;
    }
    if (set_dungeon_workflow_mode_) {
      set_dungeon_workflow_mode_(false);
      dungeon_workbench_mode = false;
      return true;
    }
    window_manager_.CloseWindow(session_id, "dungeon.workbench");
    window_manager_.OpenWindow(session_id, "dungeon.room_selector");
    window_manager_.OpenWindow(session_id, "dungeon.room_matrix");
    dungeon_workbench_mode = read_dungeon_workbench_mode();
    return !dungeon_workbench_mode;
  };
 
  auto ensure_dungeon_window_mode_for_window =
      [&](const std::string& window_id) -> bool {
    if (category != "Dungeon" || !dungeon_workbench_mode ||
        !IsDungeonPanelModeWindow(window_id)) {
      return false;
    }
    return switch_to_dungeon_window_mode();
  };
 
  if (category == "Dungeon") {
    const float workflow_gap = compact_spacing;
    const float workflow_min_button_width = 96.0f;
    const float workflow_available_width =
        std::max(1.0f, ImGui::GetContentRegionAvail().x);
    const bool stack_workflow_buttons =
        workflow_available_width <=
        (workflow_min_button_width * 2.0f + workflow_gap);
    const float workflow_button_width =
        stack_workflow_buttons
            ? workflow_available_width
            : std::max(workflow_min_button_width,
                       (workflow_available_width - workflow_gap) * 0.5f);
    const float workflow_button_height =
        std::max(24.0f, gui::LayoutHelpers::GetStandardWidgetHeight());
    auto draw_workflow_button =
        [&](const char* id, const char* icon, const char* label, bool active,
            const char* tooltip, const ImVec2& button_size) -> bool {
      const ImVec4 active_bg = gui::GetPrimaryVec4();
      const ImVec4 inactive_bg = gui::GetSurfaceContainerHighVec4();
      const ImVec4 inactive_hover = gui::GetSurfaceContainerHighestVec4();
      gui::StyleColorGuard colors(
          {{ImGuiCol_Button, active ? active_bg : inactive_bg},
           {ImGuiCol_ButtonHovered, active ? active_bg : inactive_hover},
           {ImGuiCol_ButtonActive, active ? active_bg : inactive_hover}});
      const std::string button_label =
          absl::StrFormat("%s %s##%s", icon, label, id);
      const bool clicked = ImGui::Button(button_label.c_str(), button_size);
      if (ImGui::IsItemHovered() && tooltip && *tooltip) {
        ImGui::SetTooltip("%s", tooltip);
      }
      return clicked;
    };
    const ImVec2 workflow_button_size(workflow_button_width,
                                      workflow_button_height);
 
    if (draw_workflow_button(
            "workflow_workbench", ICON_MD_WORKSPACES, "Workbench",
            dungeon_workbench_mode,
            "Workbench mode: integrated room browser + inspector",
            workflow_button_size)) {
      switch_to_dungeon_workbench_mode();
    }
    if (!stack_workflow_buttons) {
      ImGui::SameLine(0.0f, workflow_gap);
    }
    if (draw_workflow_button(
            "workflow_windows", ICON_MD_VIEW_QUILT, "Windows",
            !dungeon_workbench_mode,
            "Window mode: standalone Room List + Room Matrix + room windows",
            workflow_button_size)) {
      switch_to_dungeon_window_mode();
    }
    ImGui::Separator();
  }
 
  ImGui::Spacing();
 
  if (disable_windows) {
    ImGui::TextUnformatted(ICON_MD_FOLDER_OPEN
                           " Open a ROM to enable this category");
    ImGui::Spacing();
  }
 
  if (disable_windows) {
    ImGui::BeginDisabled();
  }
 
  const auto pinned_windows = window_manager_.GetPinnedWindows();
  const ImVec4 disabled_text = ImGui::GetStyleColorVec4(ImGuiCol_TextDisabled);
  auto window_text_color = [&](bool visible) -> ImVec4 {
    if (disable_windows) {
      return disabled_text;
    }
    return visible ? gui::GetOnSurfaceVec4() : gui::GetTextSecondaryVec4();
  };
  const ImVec2 pin_button_size = gui::ScaledSize(30.0f, 30.0f);
  auto draw_pin_toggle_button = [&](const std::string& widget_id,
                                    bool pinned) -> bool {
    ImGui::PushID(widget_id.c_str());
    ImVec4 pin_col = pinned ? gui::ConvertColorToImVec4(theme.primary)
                            : gui::GetTextSecondaryVec4();
    if (!pinned) {
      pin_col.w *= 0.72f;
    }
    const bool clicked = gui::TransparentIconButton(
        ICON_MD_PUSH_PIN, pin_button_size,
        pinned ? "Unpin window" : "Pin window", pinned, pin_col,
        "window_sidebar", widget_id.c_str());
    ImGui::PopID();
    return clicked;
  };
 
  bool pinned_section_open = false;
  if (sidebar_search_[0] == '\0' && !pinned_windows.empty()) {
    bool has_pinned_in_category = false;
    for (const auto& window_id : pinned_windows) {
      const auto* window =
          window_manager_.GetWindowDescriptor(session_id, window_id);
      if (window && window->category == category && window->IsAdmitted()) {
        has_pinned_in_category = true;
        break;
      }
    }
 
    if (has_pinned_in_category) {
      pinned_section_open = ImGui::CollapsingHeader(
          ICON_MD_PUSH_PIN " Pinned Windows", ImGuiTreeNodeFlags_DefaultOpen);
      if (pinned_section_open) {
        for (const auto& window_id : pinned_windows) {
          const auto* window =
              window_manager_.GetWindowDescriptor(session_id, window_id);
          if (!window || window->category != category ||
              !window->IsAdmitted()) {
            continue;
          }
 
          const bool visible =
              window->visibility_flag ? *window->visibility_flag : false;
 
          std::string label = absl::StrFormat("%s  %s", window->icon.c_str(),
                                              window->display_name.c_str());
          const float selectable_width =
              std::max(1.0f, ImGui::GetContentRegionAvail().x -
                                 pin_button_size.x - compact_spacing);
          ImGui::PushID(
              (std::string("pinned_select_") + window->card_id).c_str());
          {
            gui::StyleColorGuard text_color(ImGuiCol_Text,
                                            window_text_color(visible));
            ImVec2 item_size(selectable_width, pin_button_size.y);
            if (ImGui::Selectable(label.c_str(), visible,
                                  ImGuiSelectableFlags_None, item_size)) {
              const bool switched_mode =
                  ensure_dungeon_window_mode_for_window(window->card_id);
              if (switched_mode) {
                window_manager_.OpenWindow(session_id, window->card_id);
              } else {
                window_manager_.ToggleWindow(session_id, window->card_id);
              }
 
              const bool new_visible =
                  window->visibility_flag ? *window->visibility_flag : false;
              if (new_visible) {
                window_manager_.TriggerWindowClicked(window->category);
                const std::string window_name =
                    window_manager_.GetWorkspaceWindowName(*window);
                if (!window_name.empty()) {
                  ImGui::SetWindowFocus(window_name.c_str());
                }
              }
            }
          }
          ImGui::PopID();
          ImGui::SameLine(0.0f, compact_spacing);
          if (draw_pin_toggle_button("pin_" + window->card_id, true)) {
            window_manager_.SetWindowPinned(session_id, window->card_id, false);
          }
        }
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Spacing();
      }
    }
  }
 
  auto windows = window_manager_.GetWindowsSortedByMRU(session_id, category);
  const bool filtering = sidebar_search_[0] != '\0';
 
  // Bucket windows into sidebar sections (Core / Editors / Rooms / Advanced /
  // other). Pinned rows that already appear in the Pinned header are skipped.
  std::map<std::string, std::vector<WindowDescriptor>> sections;
  for (const auto& window : windows) {
    if (!window.IsListedInWindowBrowser()) {
      continue;
    }
    if (ShouldOmitWindowInSidebar(window.card_id, dungeon_workbench_mode)) {
      continue;
    }
    if (!MatchesWindowSearch(sidebar_search_, window.display_name,
                             window.card_id, window.shortcut_hint)) {
      continue;
    }
    const bool is_pinned = window_manager_.IsWindowPinned(window.card_id);
    if (pinned_section_open && is_pinned) {
      continue;
    }
    sections[SidebarSectionFor(window)].push_back(window);
  }
 
  // Within each section: priority ascending, then display name.
  for (auto& [section_name, section_windows] : sections) {
    (void)section_name;
    std::sort(section_windows.begin(), section_windows.end(),
              [](const WindowDescriptor& a, const WindowDescriptor& b) {
                if (a.priority != b.priority) {
                  return a.priority < b.priority;
                }
                return a.display_name < b.display_name;
              });
  }
 
  constexpr const char* kPreferredSectionOrder[] = {
      "Core",
      "Editors",
      "Rooms",
      "Advanced",
  };
  std::vector<std::string> section_order;
  for (const char* preferred : kPreferredSectionOrder) {
    if (sections.count(preferred)) {
      section_order.emplace_back(preferred);
    }
  }
  for (const auto& [name, _] : sections) {
    if (std::find(section_order.begin(), section_order.end(), name) ==
        section_order.end()) {
      section_order.push_back(name);
    }
  }
 
  auto draw_window_row = [&](const WindowDescriptor& window) {
    const bool is_pinned = window_manager_.IsWindowPinned(window.card_id);
    const bool visible =
        window.visibility_flag ? *window.visibility_flag : false;
 
    std::string label = absl::StrFormat("%s  %s", window.icon.c_str(),
                                        window.display_name.c_str());
    const float selectable_width =
        std::max(1.0f, ImGui::GetContentRegionAvail().x - pin_button_size.x -
                           compact_spacing);
    bool window_row_hovered = false;
    ImGui::PushID((std::string("window_select_") + window.card_id).c_str());
    {
      gui::StyleColorGuard text_color(ImGuiCol_Text,
                                      window_text_color(visible));
      ImVec2 item_size(selectable_width, pin_button_size.y);
      if (ImGui::Selectable(label.c_str(), visible, ImGuiSelectableFlags_None,
                            item_size)) {
        const bool switched_mode =
            ensure_dungeon_window_mode_for_window(window.card_id);
        if (switched_mode) {
          window_manager_.OpenWindow(session_id, window.card_id);
        } else {
          window_manager_.ToggleWindow(session_id, window.card_id);
        }
 
        const bool new_visible =
            window.visibility_flag ? *window.visibility_flag : false;
        if (new_visible) {
          window_manager_.MarkWindowRecentlyUsed(window.card_id);
          window_manager_.TriggerWindowClicked(window.category);
          const std::string window_name =
              window_manager_.GetWorkspaceWindowName(window);
          if (!window_name.empty()) {
            ImGui::SetWindowFocus(window_name.c_str());
          }
        }
      }
      window_row_hovered = ImGui::IsItemHovered();
    }
    ImGui::PopID();
    ImGui::SameLine(0.0f, compact_spacing);
    if (draw_pin_toggle_button("pin_" + window.card_id, is_pinned)) {
      window_manager_.SetWindowPinned(session_id, window.card_id, !is_pinned);
    }
 
    if (window_row_hovered && !window.shortcut_hint.empty()) {
      ImGui::SetTooltip("%s", window.shortcut_hint.c_str());
    }
  };
 
  const EditorContextSnapshot context_snapshot =
      context_provider_ ? context_provider_(category) : EditorContextSnapshot{};
  const bool has_context = HasRenderableContext(context_snapshot);
  if (disable_windows)
    ImGui::EndDisabled();
  const bool window_content_open =
      ImGui::BeginChild("##WindowContent", ImVec2(0.0f, 0.0f), false);
  if (window_content_open) {
    ImGui::BeginDisabled(disable_windows);
    for (const std::string& section_name : section_order) {
      auto it = sections.find(section_name);
      if (it == sections.end() || it->second.empty()) {
        continue;
      }
 
      // Search results are flat so a previously collapsed section cannot hide
      // a match. Do not change the ordinary section's saved expansion state.
      if (filtering) {
        for (const auto& window : it->second) {
          draw_window_row(window);
        }
        continue;
      }
 
      // Flat sections: the sidebar already provides search and one scroll
      // surface. A saved closed header must not hide an editing tool.
      ImGui::SeparatorText(section_name.c_str());
      for (const auto& window : it->second)
        draw_window_row(window);
    }
    ImGui::EndDisabled();
  }
  if (window_content_open && has_context)
    DrawEditorContext(session_id, category, context_snapshot);
  ImGui::EndChild();
 
  const float handle_width = 6.0f;
  const ImVec2 panel_pos = ImGui::GetWindowPos();
  const float panel_draw_height = ImGui::GetWindowHeight();
  ImGui::SetCursorScreenPos(
      ImVec2(panel_pos.x + panel_width - handle_width * 0.5f, panel_pos.y));
  ImGui::InvisibleButton("##SidePanelResizeHandle",
                         ImVec2(handle_width, panel_draw_height));
  const bool handle_hovered = ImGui::IsItemHovered();
  const bool handle_active = ImGui::IsItemActive();
  if (handle_hovered || handle_active) {
    ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
  }
  if (handle_hovered && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
    window_manager_.ResetSidePanelWidth();
  }
  if (handle_active) {
    const float new_width = panel_width + ImGui::GetIO().MouseDelta.x;
    window_manager_.SetActiveSidePanelWidth(new_width, viewport->WorkSize.x);
    ImGui::SetTooltip(
        tr("Width: %.0f px"),
        window_manager_.GetActiveSidePanelWidth(viewport->WorkSize.x));
  }
 
  ImVec4 handle_color = gui::GetOutlineVec4();
  handle_color.w = handle_active ? 0.95f : (handle_hovered ? 0.72f : 0.35f);
  ImGui::GetWindowDrawList()->AddLine(
      ImVec2(panel_pos.x + panel_width - 1.0f, panel_pos.y),
      ImVec2(panel_pos.x + panel_width - 1.0f, panel_pos.y + panel_draw_height),
      ImGui::GetColorU32(handle_color), handle_active ? 2.0f : 1.0f);
}
 
}  // namespace editor
}  // namespace yaze